@lunora/codegen 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/discover-ast-CT6BgBr4.mjs

@@ -0,0 +1,13 @@
+import { Node } from 'ts-morph';
+
+const TS_EXTENSION_RE = /\.ts$/u;
+const enclosingExportName = (call) => {
+  for (const ancestor of call.getAncestors()) {
+    if (Node.isVariableDeclaration(ancestor) && ancestor.getVariableStatement()?.hasExportKeyword() === true) {
+      return ancestor.getName();
+    }
+  }
+  return "";
+};
+
+export { TS_EXTENSION_RE as T, enclosingExportName as e };

package/dist/packem_shared/discoverAuthApiCalls-C35R6z0T.mjs

@@ -0,0 +1,62 @@
+import { relative, sep } from 'node:path';
+import { SyntaxKind, Node } from 'ts-morph';
+import { T as TS_EXTENSION_RE, e as enclosingExportName } from './discover-ast-CT6BgBr4.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-DEgAcRuD.mjs';
+
+const isAuthApiCall = (call) => {
+  const callee = call.getExpression();
+  if (!Node.isPropertyAccessExpression(callee)) {
+    return false;
+  }
+  const receiver = callee.getExpression();
+  if (Node.isPropertyAccessExpression(receiver)) {
+    return receiver.getName() === "authApi";
+  }
+  return Node.isIdentifier(receiver) && receiver.getText() === "authApi";
+};
+const hasHeadersProp = (call) => {
+  const argument = call.getArguments()[0];
+  if (argument === void 0) {
+    return false;
+  }
+  if (!Node.isObjectLiteralExpression(argument)) {
+    return true;
+  }
+  for (const property of argument.getProperties()) {
+    if ((Node.isPropertyAssignment(property) || Node.isShorthandPropertyAssignment(property)) && property.getName() === "headers") {
+      return true;
+    }
+    if (Node.isSpreadAssignment(property)) {
+      return true;
+    }
+  }
+  return false;
+};
+const discoverAuthApiCalls = (project, lunoraDirectory) => {
+  const calls = [];
+  for (const filePath of listLunoraSourceFiles(lunoraDirectory)) {
+    const sourceFile = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const relativePath = relative(lunoraDirectory, filePath).replace(TS_EXTENSION_RE, "").split(sep).join("/");
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      if (!isAuthApiCall(call)) {
+        continue;
+      }
+      const exportName = enclosingExportName(call);
+      if (exportName === "") {
+        continue;
+      }
+      const callee = call.getExpression();
+      const method = Node.isPropertyAccessExpression(callee) ? callee.getName() : "";
+      calls.push({
+        exportName,
+        file: relativePath,
+        hasHeaders: hasHeadersProp(call),
+        line: call.getStartLineNumber(),
+        method
+      });
+    }
+  }
+  return calls;
+};
+
+export { discoverAuthApiCalls as default };

package/dist/packem_shared/discoverCrons-BL6iGuJ3.mjs

@@ -0,0 +1,254 @@
+import { isValidCronExpression, compileCronSchedule, CRON_SCHEDULE_KINDS } from '@lunora/scheduler';
+import { SyntaxKind, Node } from 'ts-morph';
+import { listLunoraSourceFiles } from './discoverFunctions-DEgAcRuD.mjs';
+import { s as sanitizeNamespace } from './paths-BRd6JHuF.mjs';
+
+const CRON_METHODS = /* @__PURE__ */ new Set([...CRON_SCHEDULE_KINDS, "cron"]);
+const CRON_JOBS_SOURCES = /* @__PURE__ */ new Set(["@lunora/scheduler", "@lunora/server"]);
+const isCronJobsFactory = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "cronJobs";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (!CRON_JOBS_SOURCES.has(declaration.getImportDeclaration().getModuleSpecifierValue())) {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "cronJobs";
+  }
+  return false;
+};
+const collectCronBuilderNames = (source) => {
+  const names = /* @__PURE__ */ new Set();
+  for (const declaration of source.getVariableDeclarations()) {
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const callee = initializer.getExpression();
+    if (Node.isIdentifier(callee) && isCronJobsFactory(callee)) {
+      names.add(declaration.getName());
+    }
+  }
+  return names;
+};
+const rootIdentifierOf = (node) => {
+  let current = node;
+  while (Node.isCallExpression(current) || Node.isPropertyAccessExpression(current)) {
+    current = current.getExpression();
+  }
+  return Node.isIdentifier(current) ? current.getText() : void 0;
+};
+const stringArgument = (call, index) => {
+  const argument = call.getArguments()[index];
+  return argument && Node.isStringLiteral(argument) ? argument.getLiteralValue() : void 0;
+};
+const literalValue = (node, jobName) => {
+  if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
+    return node.getLiteralValue();
+  }
+  if (Node.isNumericLiteral(node)) {
+    return node.getLiteralValue();
+  }
+  if (Node.isTrueLiteral(node)) {
+    return true;
+  }
+  if (Node.isFalseLiteral(node)) {
+    return false;
+  }
+  if (Node.isPrefixUnaryExpression(node) && node.getOperatorToken() === SyntaxKind.MinusToken) {
+    const operand = node.getOperand();
+    if (Node.isNumericLiteral(operand)) {
+      return -operand.getLiteralValue();
+    }
+  }
+  if (Node.isObjectLiteralExpression(node)) {
+    return objectLiteralValue(node, jobName);
+  }
+  if (Node.isArrayLiteralExpression(node)) {
+    return node.getElements().map((element) => literalValue(element, jobName));
+  }
+  throw Object.assign(new Error(`Cron job "${jobName}" passes a non-static value where a literal is required; codegen can only read literals.`), {
+    code: "CRON_NON_STATIC_VALUE",
+    name: "LunoraError",
+    status: 500
+  });
+};
+const objectLiteralValue = (object, jobName) => {
+  const result = {};
+  for (const property of object.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      throw Object.assign(
+        new Error(`Cron job "${jobName}" uses an unsupported object property (shorthand/spread/method) where a static literal is required.`),
+        {
+          code: "CRON_NON_STATIC_VALUE",
+          name: "LunoraError",
+          status: 500
+        }
+      );
+    }
+    const initializer = property.getInitializer();
+    if (initializer) {
+      result[property.getName()] = literalValue(initializer, jobName);
+    }
+  }
+  return result;
+};
+const functionPathFromArgument = (call, index, jobName) => {
+  const argument = call.getArguments()[index];
+  if (!argument || !Node.isPropertyAccessExpression(argument)) {
+    throw Object.assign(
+      new Error(`Cron job "${jobName}" must reference a function statically (e.g. internal.email.digest); codegen cannot resolve a dynamic reference.`),
+      {
+        code: "CRON_NON_STATIC_FN",
+        name: "LunoraError",
+        status: 500
+      }
+    );
+  }
+  const functionName = argument.getName();
+  const receiver = argument.getExpression();
+  if (!Node.isPropertyAccessExpression(receiver)) {
+    throw Object.assign(new Error(`Cron job "${jobName}" function reference must be of the form internal.file.fn (two property accesses).`), {
+      code: "CRON_NON_STATIC_FN",
+      name: "LunoraError",
+      status: 500
+    });
+  }
+  const namespace = receiver.getName();
+  return `${sanitizeNamespace(namespace)}:${functionName}`;
+};
+const workflowTarget = (workflow) => {
+  return { workflow: { binding: workflow.bindingName, exportName: workflow.exportName } };
+};
+const resolveTarget = (call, index, jobName, workflowsByName) => {
+  const argument = call.getArguments()[index];
+  if (argument && Node.isPropertyAccessExpression(argument)) {
+    const receiver = argument.getExpression();
+    if (Node.isIdentifier(receiver) && receiver.getText() === "workflows") {
+      const workflow = workflowsByName.get(argument.getName());
+      if (workflow) {
+        return workflowTarget(workflow);
+      }
+      throw Object.assign(
+        new Error(`Cron job "${jobName}" targets workflows.${argument.getName()}, but no such workflow is declared in lunora/workflows.ts.`),
+        {
+          code: "CRON_NON_STATIC_FN",
+          name: "LunoraError",
+          status: 500
+        }
+      );
+    }
+    return { functionPath: functionPathFromArgument(call, index, jobName) };
+  }
+  if (argument && Node.isIdentifier(argument)) {
+    const workflow = workflowsByName.get(argument.getText());
+    if (workflow) {
+      return workflowTarget(workflow);
+    }
+    throw Object.assign(
+      new Error(
+        `Cron job "${jobName}" references "${argument.getText()}", which is neither a function (internal.file.fn / api.file.fn) nor a declared workflow in lunora/workflows.ts.`
+      ),
+      {
+        code: "CRON_NON_STATIC_FN",
+        name: "LunoraError",
+        status: 500
+      }
+    );
+  }
+  return { functionPath: functionPathFromArgument(call, index, jobName) };
+};
+const cronFromCall = (call, callee, builderNames, workflowsByName) => {
+  const method = callee.getName();
+  if (!CRON_METHODS.has(method)) {
+    return void 0;
+  }
+  if (!builderNames.has(rootIdentifierOf(callee.getExpression()) ?? "")) {
+    return void 0;
+  }
+  const name = stringArgument(call, 0);
+  if (name === void 0 || name.trim() === "") {
+    throw Object.assign(new Error(`A cron ".${method}(...)" registration must pass a non-empty string-literal name as its first argument.`), {
+      code: "CRON_NAME_NOT_STATIC",
+      name: "LunoraError",
+      status: 500
+    });
+  }
+  let cron;
+  if (method === "cron") {
+    const expression = stringArgument(call, 1);
+    if (expression === void 0) {
+      throw Object.assign(new Error(`Cron job "${name}" must pass a string-literal cron expression to ".cron(...)".`), {
+        code: "CRON_EXPR_NOT_STATIC",
+        name: "LunoraError",
+        status: 500
+      });
+    }
+    if (!isValidCronExpression(expression)) {
+      throw Object.assign(new Error(`Cron job "${name}" has an invalid cron expression "${expression}" — expected 5 or 6 space-separated fields.`), {
+        code: "CRON_EXPR_INVALID",
+        name: "LunoraError",
+        status: 500
+      });
+    }
+    cron = expression;
+  } else {
+    const scheduleArgument = call.getArguments()[1];
+    if (!scheduleArgument || !Node.isObjectLiteralExpression(scheduleArgument)) {
+      throw Object.assign(new Error(`Cron job "${name}" must pass an object-literal schedule to ".${method}(...)".`), {
+        code: "CRON_SCHEDULE_NOT_STATIC",
+        name: "LunoraError",
+        status: 500
+      });
+    }
+    cron = compileCronSchedule(method, objectLiteralValue(scheduleArgument, name));
+  }
+  const target = resolveTarget(call, 2, name, workflowsByName);
+  const argumentsNode = call.getArguments()[3];
+  const args = argumentsNode && Node.isObjectLiteralExpression(argumentsNode) ? objectLiteralValue(argumentsNode, name) : {};
+  return { args, cron, name, ...target };
+};
+const assertUniqueNames = (crons) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const cron of crons) {
+    if (seen.has(cron.name)) {
+      throw Object.assign(new Error(`Duplicate cron job name "${cron.name}": cron names must be unique across the project.`), {
+        code: "DUPLICATE_CRON_NAME",
+        name: "LunoraError",
+        status: 500
+      });
+    }
+    seen.add(cron.name);
+  }
+};
+const discoverCrons = (project, lunoraDirectory, workflows = []) => {
+  const filePaths = listLunoraSourceFiles(lunoraDirectory);
+  const crons = [];
+  const workflowsByName = new Map(workflows.map((workflow) => [workflow.exportName, workflow]));
+  for (const filePath of filePaths) {
+    const source = project.getSourceFile(filePath) ?? project.addSourceFileAtPath(filePath);
+    const builderNames = collectCronBuilderNames(source);
+    if (builderNames.size === 0) {
+      continue;
+    }
+    for (const call of source.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+      const callee = call.getExpression();
+      if (!Node.isPropertyAccessExpression(callee)) {
+        continue;
+      }
+      const cron = cronFromCall(call, callee, builderNames, workflowsByName);
+      if (cron) {
+        crons.push(cron);
+      }
+    }
+  }
+  crons.sort((a, b) => a.name.localeCompare(b.name));
+  assertUniqueNames(crons);
+  return crons;
+};
+
+export { discoverCrons as default };