@lumerahq/cli 0.19.9-dev.2 → 0.19.9

package/dist/index.js

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

package/dist/{resources-ZFGJITDH.js → resources-75I4RXB6.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,217 +138,280 @@ 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 stripJsComments(source) {
-  let out = "";
-  let inString = null;
-  let prev = "";
-  let i = 0;
-  while (i < source.length) {
-    const ch = source[i];
-    const next = source[i + 1];
-    if (inString) {
-      out += ch;
-      if (ch === inString && prev !== "\\") inString = null;
-      prev = ch;
-      i++;
-      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;
-      out += ch;
-      prev = ch;
-      i++;
-      continue;
+    if (prop.computed) {
+      throw new Error("computed keys are not supported");
     }
-    if (ch === "/" && next === "/") {
-      while (i < source.length && source[i] !== "\n") i++;
-      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 === "/" && next === "*") {
-      i += 2;
-      while (i < source.length && !(source[i] === "*" && source[i + 1] === "/")) i++;
-      i += 2;
-      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");
     }
-    out += ch;
-    prev = ch;
-    i++;
+    default:
+      throw new Error(`expected a literal value, got ${node.type}`);
   }
-  return out;
 }
-function extractTopLevelConfigKeys(configBody) {
-  if (!configBody.startsWith("{") || !configBody.endsWith("}")) return [];
-  const inner = stripJsComments(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 parseHookFile(content) {
+  const finding = {
+    configFound: false,
+    configKeys: [],
+    configIssues: [],
+    defaultHandlerFound: false
+  };
+  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;
+      }
     }
-    if (ch === '"' || ch === "'" || ch === "`") {
-      inString = ch;
-      prev = ch;
-      continue;
+  }
+  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;
     }
-    if (ch === "{" || ch === "[") {
-      depth++;
-      prev = ch;
-      continue;
+    for (const k of finding.configKeys) {
+      if (!KNOWN_HOOK_CONFIG_KEYS.has(k)) {
+        finding.configIssues.push({ kind: "unknown-key", key: k });
+      }
     }
-    if (ch === "}" || ch === "]") {
-      depth--;
-      prev = ch;
-      continue;
+    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 } : {}
+      };
     }
-    if (depth === 0) stripped += ch;
-    prev = ch;
   }
-  const keys = [];
-  const keyRe = /(?:^|,)\s*(?:['"]([^'"]+)['"]|(\w+))\s*:/g;
-  let m;
-  while ((m = keyRe.exec(stripped)) !== null) {
-    keys.push(m[1] || m[2]);
+  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 keys;
+  return finding;
 }
 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"
-  };
-  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 {
-    }
-  }
-  return hook;
+  const finding = parseHookFile(content);
+  return finding.hook ?? null;
 }
 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();
-  }
-  const simpleMatch = content.match(
-    /export\s+default\s+async\s+function[^{]*\{([\s\S]*)\}[\s\n]*$/
-  );
-  if (simpleMatch) {
-    return simpleMatch[1].trim();
-  }
-  return content.replace(/export\s+const\s+config[\s\S]*?;/, "").trim();
-}
-function hasDefaultHandler(content) {
-  return /export\s+default\s+(?:async\s+)?function\b/.test(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) {
+    if (target.filePath.endsWith(".ts")) {
       return [
         error2(
           target,
-          "Missing or unparseable `export const config = {...}`. Hook files must export a config object with at least `collection` and `trigger`."
+          "TypeScript hook files are not yet supported. Rename to `.js` and remove any TypeScript-specific syntax (type annotations, `as` casts, etc.)."
         )
       ];
     }
-    const errors = [];
-    if (!config.external_id && !ctx.appName) {
-      errors.push(
+    const finding = parseHookFile(target.source);
+    if (finding.syntaxError) {
+      return [
         error2(
           target,
-          "Hook config is missing `external_id` and no app name is configured to derive one from the file name."
+          `Could not parse hook file: ${finding.syntaxError.message}`,
+          finding.syntaxError.line
         )
-      );
+      ];
     }
-    if (!hasDefaultHandler(target.source)) {
+    if (!finding.configFound) {
+      return [
+        error2(
+          target,
+          "Missing `export const config = {...}`. Hook files must export a config object with at least `collection` and `trigger`."
+        )
+      ];
+    }
+    const errors = [];
+    if (finding.hook !== void 0 && !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);
     }
@@ -530,21 +594,34 @@ function safePrintLint(warnings, projectRoot) {
     if (process.env.LUMERA_DEBUG) console.error("[lint] print failed:", err);
   }
 }
+async function safeLintPass(label, build) {
+  try {
+    const issues = await build();
+    const errors = issues.filter((issue) => issue.severity === "error");
+    return { issues, errors };
+  } catch (err) {
+    if (process.env.LUMERA_DEBUG) console.error(`[lint] ${label} pass failed:`, err);
+    return null;
+  }
+}
 async function lintCollectionFiles(projectRoot, platformDir, filterName) {
-  const issues = await runLint({ projectRoot, targets: buildCollectionTargets(platformDir, filterName) });
-  const errors = issues.filter((issue) => issue.severity === "error");
-  if (errors.length === 0) return;
-  printLintWarnings(issues, projectRoot);
-  throw new Error(`Found ${errors.length} collection lint error(s)`);
+  const result = await safeLintPass(
+    "collection",
+    async () => runLint({ projectRoot, targets: buildCollectionTargets(platformDir, filterName) })
+  );
+  if (!result || result.errors.length === 0) return;
+  safePrintLint(result.issues, projectRoot);
+  throw new Error(`Found ${result.errors.length} collection lint error(s)`);
 }
 async function lintHookFiles(api, projectRoot, platformDir, appName, filterName) {
-  const targets = buildHookTargets(platformDir, filterName);
-  if (targets.length === 0) return;
-  const issues = await runLint({ projectRoot, targets, api, appName });
-  const errors = issues.filter((issue) => issue.severity === "error");
-  if (errors.length === 0) return;
-  printLintWarnings(issues, projectRoot);
-  throw new Error(`Found ${errors.length} hook lint error(s)`);
+  const result = await safeLintPass("hook", async () => {
+    const targets = buildHookTargets(platformDir, filterName);
+    if (targets.length === 0) return [];
+    return runLint({ projectRoot, targets, api, appName });
+  });
+  if (!result || result.errors.length === 0) return;
+  safePrintLint(result.issues, projectRoot);
+  throw new Error(`Found ${result.errors.length} hook lint error(s)`);
 }
 var PACKAGE_MANAGERS = ["bun", "pnpm", "yarn", "npm"];
 var PACKAGE_MANAGER_VALUE_FLAGS = /* @__PURE__ */ new Set(["--package-manager"]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumerahq/cli",
-  "version": "0.19.9-dev.2",
+  "version": "0.19.9",
   "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",