@lumerahq/cli 0.19.9-dev.1 → 0.19.9-dev.3

package/dist/index.js

@@ -219,25 +219,25 @@ async function main() {
     switch (command) {
       // Resource commands
       case "plan":
-        await import("./resources-5ELZGJOH.js").then((m) => m.plan(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.plan(args.slice(1)));
         break;
       case "apply":
-        await import("./resources-5ELZGJOH.js").then((m) => m.apply(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.apply(args.slice(1)));
         break;
       case "pull":
-        await import("./resources-5ELZGJOH.js").then((m) => m.pull(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.pull(args.slice(1)));
         break;
       case "destroy":
-        await import("./resources-5ELZGJOH.js").then((m) => m.destroy(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.destroy(args.slice(1)));
         break;
       case "list":
-        await import("./resources-5ELZGJOH.js").then((m) => m.list(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.list(args.slice(1)));
         break;
       case "show":
-        await import("./resources-5ELZGJOH.js").then((m) => m.show(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.show(args.slice(1)));
         break;
       case "diff":
-        await import("./resources-5ELZGJOH.js").then((m) => m.diff(args.slice(1)));
+        await import("./resources-4M4LMSSN.js").then((m) => m.diff(args.slice(1)));
         break;
       // Development
       case "dev":

package/dist/{resources-5ELZGJOH.js → resources-4M4LMSSN.js}

@@ -121,6 +121,7 @@ var collectionSchemaRule = {
 };
 
 // src/lib/hooks-parse.ts
+import { Parser } from "acorn";
 var VALID_HOOK_TRIGGERS = [
   "before_create",
   "after_create",
@@ -137,179 +138,272 @@ var KNOWN_HOOK_CONFIG_KEYS = /* @__PURE__ */ new Set([
   "enabled",
   "metadata"
 ]);
-var CONFIG_BLOCK_RE = /export\s+const\s+config\s*[=:]\s*(\{[\s\S]*?\});?/;
-function extractConfigBody(content) {
-  const m = content.match(CONFIG_BLOCK_RE);
-  return m ? m[1] : null;
-}
-function extractTopLevelConfigKeys(configBody) {
-  if (!configBody.startsWith("{") || !configBody.endsWith("}")) return [];
-  const inner = configBody.slice(1, -1);
-  let stripped = "";
-  let depth = 0;
-  let inString = null;
-  let prev = "";
-  for (const ch of inner) {
-    if (inString) {
-      if (ch === inString && prev !== "\\") inString = null;
-      prev = ch;
-      continue;
+function isLiteralString(n) {
+  return !!n && n.type === "Literal" && typeof n.value === "string";
+}
+function getPropertyKey(prop) {
+  const key = prop.key;
+  if (!key) return void 0;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && typeof key.value === "string") return key.value;
+  return void 0;
+}
+function objectExpressionToLiteral(node) {
+  const result = {};
+  for (const prop of node.properties) {
+    if (prop.type !== "Property") {
+      throw new Error("spread or shorthand properties are not supported");
     }
-    if (ch === '"' || ch === "'" || ch === "`") {
-      inString = ch;
-      prev = ch;
-      continue;
+    if (prop.computed) {
+      throw new Error("computed keys are not supported");
     }
-    if (ch === "{" || ch === "[") {
-      depth++;
-      prev = ch;
-      continue;
+    const key = getPropertyKey(prop);
+    if (key === void 0) throw new Error("non-string property key");
+    result[key] = literalNodeToValue(prop.value);
+  }
+  return result;
+}
+function literalNodeToValue(node) {
+  switch (node.type) {
+    case "Literal":
+      return node.value;
+    case "ObjectExpression":
+      return objectExpressionToLiteral(node);
+    case "ArrayExpression":
+      return node.elements.map(
+        (el) => el === null ? null : literalNodeToValue(el)
+      );
+    case "UnaryExpression": {
+      const arg = node.argument;
+      if (node.operator === "-" && arg.type === "Literal" && typeof arg.value === "number") {
+        return -arg.value;
+      }
+      throw new Error(`unsupported unary operator '${String(node.operator)}'`);
     }
-    if (ch === "}" || ch === "]") {
-      depth--;
-      prev = ch;
-      continue;
+    case "TemplateLiteral": {
+      const expressions = node.expressions;
+      const quasis = node.quasis;
+      if (expressions.length === 0 && quasis.length === 1) {
+        return quasis[0].value.cooked;
+      }
+      throw new Error("template literals with interpolation are not supported");
     }
-    if (depth === 0) stripped += ch;
-    prev = ch;
+    default:
+      throw new Error(`expected a literal value, got ${node.type}`);
   }
-  const keys = [];
-  const keyRe = /(?:^|,)\s*(?:['"]([^'"]+)['"]|(\w+))\s*:/g;
-  let m;
-  while ((m = keyRe.exec(stripped)) !== null) {
-    keys.push(m[1] || m[2]);
-  }
-  return keys;
 }
-function parseHookConfig(content) {
-  const configMatch = content.match(CONFIG_BLOCK_RE);
-  if (!configMatch) return null;
-  const externalId = configMatch[1].match(/external_id\s*:\s*['"]([^'"]+)['"]/)?.[1];
-  const collection = configMatch[1].match(/collection\s*:\s*['"]([^'"]+)['"]/)?.[1];
-  const trigger = configMatch[1].match(/trigger\s*:\s*['"]([^'"]+)['"]/)?.[1];
-  const enabled = configMatch[1].match(/enabled\s*:\s*(true|false)/)?.[1];
-  const name = configMatch[1].match(/name\s*:\s*['"]([^'"]+)['"]/)?.[1];
-  if (!collection || !trigger) return null;
-  const hook = {
-    external_id: externalId || "",
-    collection,
-    trigger,
-    enabled: enabled !== "false"
+function parseHookFile(content) {
+  const finding = {
+    configFound: false,
+    configKeys: [],
+    configIssues: [],
+    defaultHandlerFound: false
   };
-  if (name) hook.name = name;
-  const metadataMatch = configMatch[1].match(/metadata\s*:\s*(\{[^}]*\})/);
-  if (metadataMatch) {
-    try {
-      const metaStr = metadataMatch[1].replace(/'/g, '"').replace(/(\w+)\s*:/g, '"$1":').replace(/,\s*}/g, "}");
-      hook.metadata = JSON.parse(metaStr);
-    } catch {
+  let ast;
+  try {
+    ast = Parser.parse(content, {
+      ecmaVersion: "latest",
+      sourceType: "module",
+      locations: true
+    });
+  } catch (err) {
+    const e = err;
+    finding.syntaxError = {
+      message: e.message ?? String(err),
+      line: e.loc?.line,
+      column: e.loc?.column
+    };
+    return finding;
+  }
+  let configNode;
+  let handlerNode;
+  for (const node of ast.body) {
+    if (node.type === "ExportNamedDeclaration") {
+      const decl = node.declaration;
+      if (decl && decl.type === "VariableDeclaration") {
+        for (const d of decl.declarations) {
+          if (d.id?.type === "Identifier" && d.id.name === "config" && d.init?.type === "ObjectExpression") {
+            configNode = d.init;
+          }
+        }
+      }
+    } else if (node.type === "ExportDefaultDeclaration") {
+      const d = node.declaration;
+      if (d.type === "FunctionDeclaration" || d.type === "FunctionExpression" || d.type === "ArrowFunctionExpression") {
+        handlerNode = d;
+      }
     }
   }
-  return hook;
-}
-function extractHookScript(content) {
-  const handlerMatch = content.match(
-    /export\s+default\s+(?:async\s+)?function\s*(?:\w+)?\s*\([^)]*\)\s*\{([\s\S]*)\}[\s\n]*$/
-  );
-  if (handlerMatch) {
-    return handlerMatch[1].trim();
+  if (configNode) {
+    finding.configFound = true;
+    const valueNodes = {};
+    for (const prop of configNode.properties) {
+      if (prop.type !== "Property") continue;
+      const key = getPropertyKey(prop);
+      if (key === void 0) continue;
+      finding.configKeys.push(key);
+      valueNodes[key] = prop.value;
+    }
+    for (const k of finding.configKeys) {
+      if (!KNOWN_HOOK_CONFIG_KEYS.has(k)) {
+        finding.configIssues.push({ kind: "unknown-key", key: k });
+      }
+    }
+    const readString = (field) => {
+      const n = valueNodes[field];
+      if (!n) return void 0;
+      if (isLiteralString(n)) return n.value;
+      finding.configIssues.push({ kind: "non-literal-field", field });
+      return void 0;
+    };
+    const external_id = readString("external_id");
+    const collection = readString("collection");
+    const trigger = readString("trigger");
+    const name = readString("name");
+    if (!collection && !("collection" in valueNodes)) {
+      finding.configIssues.push({ kind: "missing-required-field", field: "collection" });
+    }
+    if (!trigger && !("trigger" in valueNodes)) {
+      finding.configIssues.push({ kind: "missing-required-field", field: "trigger" });
+    }
+    if (trigger && !VALID_HOOK_TRIGGERS.includes(trigger)) {
+      finding.configIssues.push({ kind: "invalid-trigger", value: trigger });
+    }
+    let enabled;
+    if ("enabled" in valueNodes) {
+      const n = valueNodes.enabled;
+      if (n.type === "Literal" && typeof n.value === "boolean") {
+        enabled = n.value;
+      } else {
+        finding.configIssues.push({
+          kind: "invalid-enabled",
+          rawSource: content.slice(n.start, n.end)
+        });
+      }
+    }
+    let metadata;
+    if ("metadata" in valueNodes) {
+      const n = valueNodes.metadata;
+      if (n.type === "ObjectExpression") {
+        try {
+          metadata = objectExpressionToLiteral(n);
+        } catch (e) {
+          finding.configIssues.push({
+            kind: "metadata-unparseable",
+            reason: e.message
+          });
+        }
+      } else {
+        finding.configIssues.push({
+          kind: "metadata-unparseable",
+          reason: "metadata must be an inline object literal"
+        });
+      }
+    }
+    if (collection && trigger) {
+      finding.hook = {
+        external_id: external_id ?? "",
+        collection,
+        trigger,
+        enabled: enabled ?? true,
+        ...name !== void 0 ? { name } : {},
+        ...metadata !== void 0 ? { metadata } : {}
+      };
+    }
   }
-  const simpleMatch = content.match(
-    /export\s+default\s+async\s+function[^{]*\{([\s\S]*)\}[\s\n]*$/
-  );
-  if (simpleMatch) {
-    return simpleMatch[1].trim();
+  if (handlerNode) {
+    finding.defaultHandlerFound = true;
+    const body = handlerNode.body;
+    if (body) {
+      if (body.type === "BlockStatement") {
+        finding.scriptBody = content.slice(body.start + 1, body.end - 1).trim();
+      } else {
+        finding.scriptBody = `return ${content.slice(body.start, body.end)};`;
+      }
+    }
   }
-  return content.replace(/export\s+const\s+config[\s\S]*?;/, "").trim();
+  return finding;
+}
+function parseHookConfig(content) {
+  const finding = parseHookFile(content);
+  return finding.hook ?? null;
 }
-function hasDefaultHandler(content) {
-  return /export\s+default\s+(?:async\s+)?function\b/.test(content);
+function extractHookScript(content) {
+  const finding = parseHookFile(content);
+  return finding.scriptBody ?? "";
 }
 
 // src/lib/lint/rules/hook-verify.ts
-function error2(target, message) {
+function error2(target, message, line) {
   return {
     ruleId: "hook-verify",
     target,
     severity: "error",
-    message
+    message,
+    ...line !== void 0 ? { line } : {}
   };
 }
+function messageForIssue(issue) {
+  switch (issue.kind) {
+    case "missing-required-field":
+      return `Hook config is missing required field '${issue.field}'.`;
+    case "unknown-key":
+      return `Unknown config key '${issue.key}'. Known keys: ${[...KNOWN_HOOK_CONFIG_KEYS].join(", ")}.`;
+    case "invalid-trigger":
+      return `Invalid trigger '${issue.value}'. Must be one of: ${VALID_HOOK_TRIGGERS.join(", ")}.`;
+    case "invalid-enabled":
+      return `Invalid 'enabled' value \`${issue.rawSource}\`. Must be a literal \`true\` or \`false\`.`;
+    case "metadata-unparseable":
+      return `Could not parse 'metadata': ${issue.reason}. It must be an inline object literal with literal values (strings, numbers, booleans, null, arrays, or nested literal objects).`;
+    case "non-literal-field":
+      return `Field '${issue.field}' must be a string literal.`;
+  }
+}
 var hookVerifyRule = {
   id: "hook-verify",
   description: "Validates hook file structure (config export, trigger, known keys, default handler) and verifies the script compiles via the backend.",
   appliesTo: ["hook"],
   async check(target, ctx) {
-    const config = parseHookConfig(target.source);
-    if (!config) {
+    const finding = parseHookFile(target.source);
+    if (finding.syntaxError) {
       return [
         error2(
           target,
-          "Missing or unparseable `export const config = {...}`. Hook files must export a config object with at least `collection` and `trigger`."
+          `Could not parse hook file: ${finding.syntaxError.message}`,
+          finding.syntaxError.line
         )
       ];
     }
-    const errors = [];
-    if (!config.external_id && !ctx.appName) {
-      errors.push(
+    if (!finding.configFound) {
+      return [
         error2(
           target,
-          "Hook config is missing `external_id` and no app name is configured to derive one from the file name."
+          "Missing `export const config = {...}`. Hook files must export a config object with at least `collection` and `trigger`."
         )
-      );
+      ];
     }
-    if (!hasDefaultHandler(target.source)) {
+    const errors = [];
+    if (!finding.hook?.external_id && !ctx.appName) {
       errors.push(
         error2(
           target,
-          "Missing default exported handler. Hook files must `export default function(ctx) { ... }` (async allowed)."
+          "Hook config is missing `external_id` and no app name is configured to derive one from the file name."
         )
       );
     }
-    if (!VALID_HOOK_TRIGGERS.includes(config.trigger)) {
+    if (!finding.defaultHandlerFound) {
       errors.push(
         error2(
           target,
-          `Invalid trigger '${config.trigger}'. Must be one of: ${VALID_HOOK_TRIGGERS.join(", ")}.`
+          "Missing default exported handler. Hook files must `export default function(ctx) { ... }` (async or arrow allowed)."
         )
       );
     }
-    const configBody = extractConfigBody(target.source);
-    if (configBody) {
-      const keys = extractTopLevelConfigKeys(configBody);
-      for (const key of keys) {
-        if (!KNOWN_HOOK_CONFIG_KEYS.has(key)) {
-          errors.push(
-            error2(
-              target,
-              `Unknown config key '${key}'. Known keys: ${[...KNOWN_HOOK_CONFIG_KEYS].join(", ")}.`
-            )
-          );
-        }
-      }
-      if (keys.includes("enabled")) {
-        const m = configBody.match(/enabled\s*:\s*([^,}\n]+)/);
-        const raw = m ? m[1].trim().replace(/,\s*$/, "").trim() : "";
-        if (raw !== "true" && raw !== "false") {
-          errors.push(
-            error2(
-              target,
-              `Invalid 'enabled' value '${raw}'. Must be a literal \`true\` or \`false\`.`
-            )
-          );
-        }
-      }
-      if (keys.includes("metadata") && !config.metadata) {
-        errors.push(
-          error2(
-            target,
-            "Could not parse 'metadata'. It must be an inline object literal with simple key/value pairs (e.g. `{ threshold: 100 }`); nested objects and non-literal values are not supported."
-          )
-        );
-      }
+    for (const issue of finding.configIssues) {
+      errors.push(error2(target, messageForIssue(issue)));
     }
     if (errors.length > 0) return errors;
-    let script = extractHookScript(target.source);
+    let script = finding.scriptBody ?? "";
     if (ctx.appName) {
       script = script.replaceAll("{{app}}", ctx.appName);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.19.9-dev.1",
+  "version": "0.19.9-dev.3",
   "description": "CLI for building and deploying Lumera apps",
   "type": "module",
   "engines": {
@@ -14,6 +14,7 @@
     "templates"
   ],
   "dependencies": {
+    "acorn": "^8.16.0",
     "archiver": "^7.0.1",
     "dotenv": "^16.4.7",
     "open": "^10.1.0",