@lunora/codegen 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/discoverCrons-Cev7RRAf.mjs

@@ -0,0 +1,257 @@
+import { isValidCronExpression, compileCronSchedule, CRON_SCHEDULE_KINDS } from '@lunora/scheduler';
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.mjs';
+import { listLunoraSourceFiles } from './discoverFunctions-BWMczzBx.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 diagnosticAt(node, `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 diagnosticAt(
+        property,
+        `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 diagnosticAt(
+      call,
+      `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 diagnosticAt(argument, `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 diagnosticAt(
+        argument,
+        `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 diagnosticAt(
+      argument,
+      `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 diagnosticAt(call, `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 diagnosticAt(call, `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 diagnosticAt(call, `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 diagnosticAt(call, `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 };