feat: models + fix logs + decorators + wip

Author: devthejo

.yarn/patches/@kubernetes-models-crd-generate-npm-5.0.2-d0c40558b7.patch

@@ -28,7 +28,7 @@
     "@eslint/compat": "^1.2.7",
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.23.0",
-    "@kubernetes-models/crd-generate": "^5.0.2",
+    "@kubernetes-models/crd-generate": "patch:@kubernetes-models/crd-generate@npm%3A5.0.2#~/.yarn/patches/@kubernetes-models-crd-generate-npm-5.0.2-d0c40558b7.patch",
     "@types/chai": "^5.2.0",
     "@types/fs-extra": "^11",
     "@types/js-yaml": "^4",

package.json

@@ -90,6 +90,12 @@ async function bundleTypeScript(
       minify: false,
       keepNames: true,
       legalComments: "inline",
+      // Enable TypeScript decorators
+      tsconfigRaw: {
+        compilerOptions: {
+          experimentalDecorators: true,
+        },
+      },
     }
 
     // If embedDeps is false, add plugin to keep dependencies external

packages/cli/src/commands/compo/index.ts

@@ -1,7 +1,7 @@
 import { createLogger } from "@crossplane-js/libs"
 
+import { createModel } from "./model.ts"
 import type { NodeResponse, NodeError, FunctionInput } from "./types.ts"
-// import { createModel } from "./model.ts"
 
 // Create a logger for this module
 const moduleLogger = createLogger("executor")
@@ -61,11 +61,9 @@ export async function executeCode(
       try {
         const inputData = input as any
 
-        result = await module.default(inputData)
-        // WIP
-        // const compositeResource = inputData?.observed?.composite?.resource
-        // const composite = createModel(compositeResource)
-        // result = await module.default(composite)
+        const compositeResource = inputData?.observed?.composite?.resource
+        const composite = createModel(compositeResource)
+        result = await module.default(composite)
 
         moduleLogger.debug("Function execution completed")
       } catch (execErr) {

packages/server/src/executor.ts

@@ -38,40 +38,63 @@ export function createServer(port: number, codeFilePath: string) {
     try {
       const { input } = req.body as NodeRequest
 
-      // Enhanced logging of the full request body
-      moduleLogger.debug({ body: req.body }, "=== REQUEST RECEIVED ===")
+      // Log request metadata without sensitive content
+      moduleLogger.debug("=== REQUEST RECEIVED ===")
+      moduleLogger.debug(`Request method: ${req.method}, path: ${req.path}`)
+      moduleLogger.debug(`Input data size: ${JSON.stringify(input).length} bytes`)
 
-      // Specifically log observed resources if present
+      // Specifically log observed resources if present (without full content)
       if (req.body.observed) {
         moduleLogger.debug("=== OBSERVED RESOURCES ===")
 
-        // Log composite resource if present
+        // Log composite resource metadata if present
         if (req.body.observed.composite) {
-          moduleLogger.debug({ composite: req.body.observed.composite }, "Composite Resource:")
+          const composite = req.body.observed.composite
+          moduleLogger.debug(
+            {
+              compositeKind: composite.resource?.kind,
+              compositeName: composite.resource?.metadata?.name,
+              compositeNamespace: composite.resource?.metadata?.namespace,
+            },
+            "Composite Resource metadata"
+          )
         }
 
-        // Log individual resources if present
+        // Log individual resources metadata if present
         if (req.body.observed.resources) {
-          moduleLogger.info("Resources:")
           const resourceNames = Object.keys(req.body.observed.resources)
           moduleLogger.info(`Found ${resourceNames.length} resources: ${resourceNames.join(", ")}`)
 
-          // Log each resource
+          // Log each resource metadata (not full content)
           for (const [name, resource] of Object.entries(req.body.observed.resources)) {
-            moduleLogger.info({ resource }, `Resource "${name}"`)
+            const resourceObj = resource as any
+            moduleLogger.info(
+              {
+                resourceName: name,
+                kind: resourceObj.resource?.kind,
+                name: resourceObj.resource?.metadata?.name,
+                namespace: resourceObj.resource?.metadata?.namespace,
+              },
+              `Resource "${name}" metadata`
+            )
           }
         }
       }
 
       moduleLogger.info("=== EXECUTING CODE ===")
-      moduleLogger.info(`Input length: ${JSON.stringify(input).length}`)
 
       const result = await executeCode(codeFilePath, input)
 
       moduleLogger.info("=== CODE EXECUTION COMPLETED ===")
 
-      // Log the response for debugging
-      moduleLogger.debug(`Execute response: ${JSON.stringify(result, null, 2)}`)
+      // Log response metadata without full content
+      if (result.error) {
+        moduleLogger.debug(`Execute response: error - ${result.error.message}`)
+      } else {
+        moduleLogger.debug(
+          `Execute response: success - result size: ${JSON.stringify(result.result || {}).length} bytes`
+        )
+      }
 
       res.json(result)
     } catch (err: unknown) {

packages/server/src/server.ts

@@ -12,6 +12,7 @@ import (
 type logWriter struct {
 	logger     logger.Logger
 	prefix     string
+	streamType string // "stdout" or "stderr"
 	buffer     []byte
 	bufferLock sync.Mutex
 }
@@ -29,49 +30,103 @@ func (w *logWriter) Write(p []byte) (n int, err error) {
 	// Log each complete line
 	for _, line := range lines {
 		if line != "" {
-			// Try to parse the line as JSON
-			var jsonData map[string]interface{}
-			if err := json.Unmarshal([]byte(line), &jsonData); err == nil {
-				// Successfully parsed as JSON
-				// Create a new map with "js-" prefix for each key
-				prefixedData := make(map[string]interface{})
-				for k, v := range jsonData {
-					prefixedData["js-"+k] = v
-				}
-
-				// Check if this is an error message
-				if _, hasError := jsonData["error"]; hasError {
-					// Log as an error with fields
-					w.logger.WithFields(prefixedData).
-						WithField(logger.FieldComponent, "node").
-						Error("Node.js process reported an error")
-				} else {
-					// Log as info with fields
-					w.logger.WithFields(prefixedData).
-						WithField(logger.FieldComponent, "node").
-						Info(w.prefix)
-				}
-			} else {
-				// Check if this looks like an error message
-				if strings.Contains(strings.ToLower(line), "error") ||
-					strings.Contains(strings.ToLower(line), "exception") ||
-					strings.Contains(strings.ToLower(line), "fail") {
-					// Log as an error
-					w.logger.WithField(logger.FieldComponent, "node").
-						WithField(logger.FieldError, line).
-						Error("Node.js process reported an error")
-				} else {
-					// Log as plain text
-					w.logger.WithField(logger.FieldComponent, "node").
-						Infof("%s%s", w.prefix, line)
-				}
-			}
+			w.logLine(line)
 		}
 	}
 
 	return len(p), nil
 }
 
+// logLine processes and logs a single line
+func (w *logWriter) logLine(line string) {
+	// Add stream type to logger context
+	contextLogger := w.logger.WithField(logger.FieldComponent, "node").
+		WithField("stream", w.streamType)
+
+	// Try to parse the line as JSON (Pino format)
+	var jsonData map[string]interface{}
+	if err := json.Unmarshal([]byte(line), &jsonData); err == nil {
+		// Successfully parsed as JSON - this is likely Pino output
+		w.logPinoMessage(contextLogger, jsonData)
+	} else {
+		// Not JSON - handle as plain text
+		w.logPlainText(contextLogger, line)
+	}
+}
+
+// logPinoMessage handles structured Pino log messages
+func (w *logWriter) logPinoMessage(contextLogger logger.Logger, jsonData map[string]interface{}) {
+	// Create a new map with "js-" prefix for each key to avoid conflicts
+	prefixedData := make(map[string]interface{})
+	for k, v := range jsonData {
+		prefixedData["js-"+k] = v
+	}
+
+	// Extract log level from Pino message
+	var logLevel string
+	if level, ok := jsonData["level"].(string); ok {
+		logLevel = strings.ToUpper(level)
+	} else if levelNum, ok := jsonData["level"].(float64); ok {
+		// Pino uses numeric levels: 10=trace, 20=debug, 30=info, 40=warn, 50=error, 60=fatal
+		switch int(levelNum) {
+		case 10:
+			logLevel = "TRACE"
+		case 20:
+			logLevel = "DEBUG"
+		case 30:
+			logLevel = "INFO"
+		case 40:
+			logLevel = "WARN"
+		case 50:
+			logLevel = "ERROR"
+		case 60:
+			logLevel = "FATAL"
+		default:
+			logLevel = "INFO"
+		}
+	}
+
+	// Extract message
+	var message string
+	if msg, ok := jsonData["msg"].(string); ok {
+		message = msg
+	} else {
+		message = w.prefix
+	}
+
+	// Log based on the original level and stream type
+	loggerWithFields := contextLogger.WithFields(prefixedData)
+
+	// For stderr or error levels, log as error
+	if w.streamType == "stderr" || logLevel == "ERROR" || logLevel == "FATAL" {
+		loggerWithFields.Error(message)
+	} else if logLevel == "WARN" {
+		loggerWithFields.Warn(message)
+	} else if logLevel == "DEBUG" || logLevel == "TRACE" {
+		loggerWithFields.Debug(message)
+	} else {
+		// Default to info for stdout and info level
+		loggerWithFields.Info(message)
+	}
+}
+
+// logPlainText handles unstructured text messages
+func (w *logWriter) logPlainText(contextLogger logger.Logger, line string) {
+	// Check if this looks like an error message or if it's from stderr
+	isError := w.streamType == "stderr" ||
+		strings.Contains(strings.ToLower(line), "error") ||
+		strings.Contains(strings.ToLower(line), "exception") ||
+		strings.Contains(strings.ToLower(line), "fail") ||
+		strings.Contains(strings.ToLower(line), "fatal")
+
+	if isError {
+		contextLogger.WithField(logger.FieldError, line).
+			Error("Node.js process output")
+	} else {
+		contextLogger.Infof("%s%s", w.prefix, line)
+	}
+}
+
 // processBuffer processes the buffer and returns complete lines
 // Any incomplete line at the end remains in the buffer
 func (w *logWriter) processBuffer() []string {

pkg/node/logwriter.go

@@ -436,19 +436,18 @@ func (pm *ProcessManager) getOrCreateProcess(ctx context.Context, input *types.X
 	procLogger.Info("Running yarn install")
 	yarnCmd := exec.Command("yarn", "install")
 	yarnCmd.Dir = uniqueDirPath // Set the working directory
-	yarnCmd.Env = append(os.Environ(),
-		"NODE_OPTIONS=--experimental-strip-types --experimental-transform-types --no-warnings",
-		"NODE_NO_WARNINGS=1",
-	)
+	yarnCmd.Env = os.Environ()
 
 	// Create a custom logWriter for yarn output
 	yarnStdoutWriter := &logWriter{
-		logger: procLogger.WithField("yarn", "stdout"),
-		prefix: fmt.Sprintf("yarn[%s]: ", specHash[:8]),
+		logger:     procLogger.WithField("yarn", "stdout"),
+		prefix:     fmt.Sprintf("yarn[%s]: ", specHash[:8]),
+		streamType: "stdout",
 	}
 	yarnStderrWriter := &logWriter{
-		logger: procLogger.WithField("yarn", "stderr"),
-		prefix: fmt.Sprintf("yarn[%s]: ", specHash[:8]),
+		logger:     procLogger.WithField("yarn", "stderr"),
+		prefix:     fmt.Sprintf("yarn[%s]: ", specHash[:8]),
+		streamType: "stderr",
 	}
 
 	yarnCmd.Stdout = yarnStdoutWriter
@@ -474,17 +473,24 @@ func (pm *ProcessManager) getOrCreateProcess(ctx context.Context, input *types.X
 
 	cmd.Env = append(os.Environ(),
 		fmt.Sprintf("PORT=%d", port),
-		"NODE_OPTIONS=--experimental-strip-types --experimental-transform-types --no-warnings",
-		"NODE_NO_WARNINGS=1",
+		"XFUNCJS_LOG_LEVEL=debug", // Ensure we capture all logs from Node.js
+		"LOG_LEVEL=debug",         // Fallback for Pino logger
 	)
 
-	// Create a custom logWriter
+	// Create custom logWriters for both stdout and stderr
+	stdoutWriter := &logWriter{
+		logger:     procLogger,
+		prefix:     fmt.Sprintf("node[%s]: ", specHash[:8]),
+		streamType: "stdout",
+	}
 	stderrWriter := &logWriter{
-		logger: procLogger,
-		prefix: fmt.Sprintf("node[%s]: ", specHash[:8]),
+		logger:     procLogger,
+		prefix:     fmt.Sprintf("node[%s]: ", specHash[:8]),
+		streamType: "stderr",
 	}
 
-	// Redirect stderr to our logger
+	// Redirect both stdout and stderr to our loggers
+	cmd.Stdout = stdoutWriter
 	cmd.Stderr = stderrWriter
 
 	// Start the process