@jay-framework/plugin-validator 0.20.0 → 0.21.0

package/dist/index.js

@@ -451,6 +451,14 @@ async function validateSchema(context, result) {
             location: "plugin.yaml",
             suggestion: 'Specify the exported member name from the module (e.g., "moodTracker")'
           });
+        } else {
+          validateHandlerRef(
+            contract.component,
+            `Contract "${contract.name}" component`,
+            `plugin.yaml contracts[${index}]`,
+            context,
+            result
+          );
         }
       });
     }
@@ -483,6 +491,24 @@ async function validateSchema(context, result) {
           suggestion: 'Specify prefix for dynamic contract names (e.g., "cms")'
         });
       }
+      if (config.component) {
+        validateHandlerRef(
+          config.component,
+          `dynamic_contracts[${prefix}] component`,
+          `plugin.yaml dynamic_contracts`,
+          context,
+          result
+        );
+      }
+      if (config.generator) {
+        validateHandlerRef(
+          config.generator,
+          `dynamic_contracts[${prefix}] generator`,
+          `plugin.yaml dynamic_contracts`,
+          context,
+          result
+        );
+      }
     }
   }
   if (!manifest.contracts && !manifest.dynamic_contracts) {
@@ -553,6 +579,23 @@ async function validateSchema(context, result) {
       });
     }
   }
+  if (manifest.actions) {
+    for (const entry of manifest.actions) {
+      const exportName = typeof entry === "string" ? entry : entry.name;
+      if (exportName) {
+        validateHandlerRef(
+          exportName,
+          `Action "${exportName}"`,
+          "plugin.yaml actions",
+          context,
+          result
+        );
+      }
+    }
+  }
+  if (manifest.init) {
+    validateHandlerRef(manifest.init, "Init handler", "plugin.yaml init", context, result);
+  }
   if (manifest.routes) {
     if (!Array.isArray(manifest.routes)) {
       result.errors.push({
@@ -584,6 +627,14 @@ async function validateSchema(context, result) {
             location: "plugin.yaml",
             suggestion: "Specify the exported member name for the page component"
           });
+        } else {
+          validateHandlerRef(
+            route.component,
+            `Route "${route.path}" component`,
+            `plugin.yaml routes`,
+            context,
+            result
+          );
         }
         if (route.jayHtml) {
           validateDocFile(
@@ -623,22 +674,105 @@ async function validateSchema(context, result) {
             suggestion: "Specify the relative path to the validator handler module"
           });
         }
-        if (validator.handler && !context.isNpmPackage) {
-          const handlerPath = path.join(context.pluginPath, validator.handler);
-          const extensions = ["", ".ts", ".js", "/index.ts", "/index.js"];
-          const found = extensions.some((ext) => fs.existsSync(handlerPath + ext));
-          if (!found) {
-            result.errors.push({
-              type: "file-missing",
-              message: `Validator "${validator.name}" handler not found: ${validator.handler}`,
-              location: "plugin.yaml validators",
-              suggestion: `Create the validator handler at ${handlerPath}.ts`
-            });
-          }
+        if (validator.handler) {
+          validateHandlerRef(
+            validator.handler,
+            `Validator "${validator.name}" handler`,
+            "plugin.yaml validators",
+            context,
+            result
+          );
         }
       });
     }
   }
+  if (manifest.setup) {
+    if (manifest.setup.handler) {
+      validateHandlerRef(
+        manifest.setup.handler,
+        "Setup handler",
+        "plugin.yaml setup.handler",
+        context,
+        result
+      );
+    }
+    if (manifest.setup.references) {
+      validateHandlerRef(
+        manifest.setup.references,
+        "References handler",
+        "plugin.yaml setup.references",
+        context,
+        result
+      );
+    }
+  }
+}
+function checkExportExists(exportName, context) {
+  const packageJsonPath = path.join(context.pluginPath, "package.json");
+  if (!fs.existsSync(packageJsonPath))
+    return true;
+  let mainPath;
+  try {
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    if (packageJson.exports?.["."]) {
+      const entry = packageJson.exports["."];
+      const entryPath = typeof entry === "string" ? entry : entry.default || entry.import;
+      if (entryPath)
+        mainPath = path.join(context.pluginPath, entryPath);
+    }
+    if (!mainPath && packageJson.main) {
+      mainPath = path.join(context.pluginPath, packageJson.main);
+    }
+  } catch {
+    return true;
+  }
+  if (!mainPath || !fs.existsSync(mainPath))
+    return true;
+  try {
+    const content = fs.readFileSync(mainPath, "utf-8");
+    const patterns = [
+      new RegExp(`export\\s*\\{[^}]*\\b${exportName}\\b[^}]*\\}`, "m"),
+      new RegExp(`export\\s+(?:async\\s+)?function\\s+${exportName}\\b`),
+      new RegExp(`export\\s+(?:const|let|var)\\s+${exportName}\\b`)
+    ];
+    return patterns.some((p) => p.test(content));
+  } catch {
+    return true;
+  }
+}
+function isRelativePath(value) {
+  return value.startsWith("./") || value.startsWith("../");
+}
+function validateHandlerRef(value, label, location, context, result) {
+  if (context.isNpmPackage) {
+    if (isRelativePath(value)) {
+      result.errors.push({
+        type: "export-mismatch",
+        message: `${label} "${value}" is a relative path, but NPM plugins must use an export name`,
+        location,
+        suggestion: `Export the function from the package entry point and use the export name instead of a path`
+      });
+    } else if (!checkExportExists(value, context)) {
+      result.errors.push({
+        type: "export-mismatch",
+        message: `${label} "${value}" is not exported from the package`,
+        location,
+        suggestion: `Add "export { ${value} } from '...'" to the package entry point`
+      });
+    }
+  } else if (isRelativePath(value)) {
+    const handlerPath = path.join(context.pluginPath, value);
+    const extensions = ["", ".ts", ".js", "/index.ts", "/index.js"];
+    const found = extensions.some((ext) => fs.existsSync(handlerPath + ext));
+    if (!found) {
+      result.errors.push({
+        type: "file-missing",
+        message: `${label} not found: ${value}`,
+        location,
+        suggestion: `Create the handler at ${handlerPath}.ts`
+      });
+    }
+  }
 }
 function resolveContractFile(contractSpec, context) {
   if (context.isNpmPackage) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jay-framework/plugin-validator",
-  "version": "0.20.0",
+  "version": "0.21.0",
   "type": "module",
   "license": "Apache-2.0",
   "description": "Validation tool for Jay Stack plugins",
@@ -25,15 +25,15 @@
     "test:watch": ":"
   },
   "dependencies": {
-    "@jay-framework/compiler-jay-html": "^0.20.0",
-    "@jay-framework/compiler-shared": "^0.20.0",
-    "@jay-framework/editor-protocol": "^0.20.0",
-    "@jay-framework/typescript-bridge": "^0.20.0",
+    "@jay-framework/compiler-jay-html": "^0.21.0",
+    "@jay-framework/compiler-shared": "^0.21.0",
+    "@jay-framework/editor-protocol": "^0.21.0",
+    "@jay-framework/typescript-bridge": "^0.21.0",
     "chalk": "^4.1.2",
     "yaml": "^2.3.4"
   },
   "devDependencies": {
-    "@jay-framework/dev-environment": "^0.20.0",
+    "@jay-framework/dev-environment": "^0.21.0",
     "@types/node": "^22.15.21",
     "rimraf": "^5.0.5",
     "tsup": "^8.0.1",