@lunora/codegen 1.0.0-alpha.7 → 1.0.0-alpha.70

package/dist/packem_shared/discoverCrons-BL6iGuJ3.mjs

@@ -1,254 +0,0 @@
-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 };