@lunora/codegen 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,29 @@
+export { formatAdvisories, lintSchema } from './packem_shared/formatAdvisories-8NIv1k0I.mjs';
+export { CodegenDiagnosticError, diagnosticAt } from './packem_shared/CodegenDiagnosticError-DeblMkzO.mjs';
+export { default as discoverAuthApiCalls } from './packem_shared/discoverAuthApiCalls-CoirYbg6.mjs';
+export { CONTAINERS_FILENAME, discoverContainers } from './packem_shared/CONTAINERS_FILENAME-DlP6YM_Q.mjs';
+export { default as discoverCrons } from './packem_shared/discoverCrons-Cev7RRAf.mjs';
+export { discoverFunctions } from './packem_shared/discoverFunctions-BWMczzBx.mjs';
+export { default as discoverHttpRoutes } from './packem_shared/discoverHttpRoutes-CfP6cMzt.mjs';
+export { default as discoverInserts } from './packem_shared/discoverInserts-C7zxXkUf.mjs';
+export { default as discoverMaskProcedures } from './packem_shared/discoverMaskProcedures-Cm81kwrb.mjs';
+export { default as discoverMigrations } from './packem_shared/discoverMigrations-Bi5nJ0mJ.mjs';
+export { default as discoverNondeterministicCalls } from './packem_shared/discoverNondeterministicCalls-C4M8AXmQ.mjs';
+export { default as discoverQueries } from './packem_shared/discoverQueries-B0wGT-xe.mjs';
+export { default as discoverR2sqlCalls } from './packem_shared/discoverR2sqlCalls-BVNMd428.mjs';
+export { discoverRlsMetadata, default as discoverRlsProcedures } from './packem_shared/discoverRlsMetadata-BS9GOGC5.mjs';
+export { default as discoverSchema } from './packem_shared/discoverSchema-BnWHHJ4T.mjs';
+export { default as discoverStorageRulesMetadata } from './packem_shared/discoverStorageRulesMetadata-Da8BKXcI.mjs';
+export { WORKFLOWS_FILENAME, discoverWorkflows } from './packem_shared/WORKFLOWS_FILENAME-D62dcBGg.mjs';
+export { GENERATED_HEADER, emitApi, emitContainers, emitCrons, emitDataModel, emitDrizzleSchema, emitFunctions, emitServer, emitShard, emitVectors, emitWorkflows, emitWranglerCronTriggers } from './packem_shared/GENERATED_HEADER-BiFXNUvo.mjs';
+export { emitApp } from './packem_shared/emitApp-KfMaKXWe.mjs';
+export { buildOpenApiDocument, emitOpenApi, emitOpenApiModule } from './packem_shared/buildOpenApiDocument-Cu3mZl-8.mjs';
+export { OPENRPC_VERSION, buildOpenRpcDocument, emitOpenRpc, emitOpenRpcModule } from './packem_shared/OPENRPC_VERSION-B4i9Qp3v.mjs';
+export { SCHEMA_SNAPSHOT_FILENAME, createCodegenProject, refreshCodegenProject, runCodegen } from './packem_shared/SCHEMA_SNAPSHOT_FILENAME-Bvv7qa_u.mjs';
+export { SCHEMA_SNAPSHOT_VERSION, SchemaSnapshotParseError, buildSchemaSnapshot, diffSchemaSnapshots, evaluateSchemaDrift, parseSchemaSnapshot, serializeSchemaSnapshot } from './packem_shared/SCHEMA_SNAPSHOT_VERSION-wWGP2_5E.mjs';
+export { schemaFromIr } from './packem_shared/schemaFromIr-DTYsLBaA.mjs';
+export { LUNORA_ERROR_CODES, validatorIrToJsonSchema } from './packem_shared/LUNORA_ERROR_CODES-CySpQPD3.mjs';
+
+const VERSION = "0.0.0";
+
+export { VERSION };

package/dist/packem_shared/CONTAINERS_FILENAME-DlP6YM_Q.mjs

@@ -0,0 +1,224 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { containerClassName, containerBindingName, normalizeContainerImage } from '@lunora/container';
+import { SyntaxKind, Node } from 'ts-morph';
+import { diagnosticAt } from './CodegenDiagnosticError-DeblMkzO.mjs';
+
+const CONTAINERS_FILENAME = "containers.ts";
+const isDefineContainer = (identifier) => {
+  const symbol = identifier.getSymbol();
+  if (!symbol) {
+    return identifier.getText() === "defineContainer";
+  }
+  for (const declaration of symbol.getDeclarations()) {
+    if (!Node.isImportSpecifier(declaration)) {
+      continue;
+    }
+    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/container") {
+      return false;
+    }
+    return declaration.getNameNode().getText() === "defineContainer";
+  }
+  return false;
+};
+const stringProperty = (expression, exportName, property) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `container "${exportName}": \`${property}\` must be a static string literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const numberProperty = (expression, exportName, property) => {
+  if (Node.isNumericLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  throw diagnosticAt(
+    expression,
+    `container "${exportName}": \`${property}\` must be a static number literal — it is deploy configuration codegen writes into wrangler.jsonc`
+  );
+};
+const imageFromExpression = (expression, exportName) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return normalizeContainerImage(expression.getLiteralValue());
+  }
+  if (Node.isObjectLiteralExpression(expression)) {
+    const registry = expression.getProperty("registry");
+    if (registry && Node.isPropertyAssignment(registry)) {
+      const initializer = registry.getInitializerOrThrow();
+      return normalizeContainerImage({ registry: stringProperty(initializer, exportName, "image.registry") });
+    }
+    const build = expression.getProperty("build");
+    if (build && Node.isPropertyAssignment(build)) {
+      const initializer = build.getInitializerOrThrow();
+      return normalizeContainerImage({ build: stringProperty(initializer, exportName, "image.build") });
+    }
+  }
+  throw diagnosticAt(expression, `container "${exportName}": \`image\` must be a static string path, { registry: "…" }, or { build: "…" } literal`);
+};
+const stringRecordLiteral = (expression) => {
+  if (!Node.isObjectLiteralExpression(expression)) {
+    return void 0;
+  }
+  const record = {};
+  for (const property of expression.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const value = property.getInitializerOrThrow();
+    if (Node.isStringLiteral(value) || Node.isNoSubstitutionTemplateLiteral(value)) {
+      record[property.getName()] = value.getLiteralValue();
+    }
+  }
+  return Object.keys(record).length > 0 ? record : void 0;
+};
+const rolloutLiteral = (expression) => {
+  if (!Node.isObjectLiteralExpression(expression)) {
+    return void 0;
+  }
+  const rollout = {};
+  for (const property of expression.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const key = property.getName();
+    const value = property.getInitializerOrThrow();
+    if (Node.isNumericLiteral(value) && (key === "gracePeriodSeconds" || key === "stepPercentage")) {
+      rollout[key] = value.getLiteralValue();
+    }
+  }
+  return rollout.gracePeriodSeconds === void 0 && rollout.stepPercentage === void 0 ? void 0 : rollout;
+};
+const booleanLiteral = (expression) => {
+  if (Node.isTrueLiteral(expression)) {
+    return true;
+  }
+  if (Node.isFalseLiteral(expression)) {
+    return false;
+  }
+  return void 0;
+};
+const stringOrNumberLiteral = (expression) => {
+  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  if (Node.isNumericLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  return void 0;
+};
+const instanceTypeFromExpression = (expression, exportName) => {
+  if (Node.isStringLiteral(expression)) {
+    return expression.getLiteralValue();
+  }
+  if (Node.isObjectLiteralExpression(expression)) {
+    const custom = {};
+    for (const property of expression.getProperties()) {
+      if (!Node.isPropertyAssignment(property)) {
+        throw diagnosticAt(property, `container "${exportName}": \`instanceType\` must be an object of static number literals`);
+      }
+      const key = property.getName();
+      if (key !== "diskMb" && key !== "memoryMib" && key !== "vcpu") {
+        throw diagnosticAt(property, `container "${exportName}": unknown \`instanceType\` field "${key}" — expected vcpu, memoryMib, or diskMb`);
+      }
+      custom[key] = numberProperty(property.getInitializerOrThrow(), exportName, `instanceType.${key}`);
+    }
+    return custom;
+  }
+  throw diagnosticAt(expression, `container "${exportName}": \`instanceType\` must be a static string or { vcpu, memoryMib, diskMb } literal`);
+};
+const containerFromCall = (call, exportName) => {
+  const argument = call.getArguments()[0];
+  if (!argument || !Node.isObjectLiteralExpression(argument)) {
+    throw diagnosticAt(call, `container "${exportName}": defineContainer must be passed an inline object literal`);
+  }
+  const ir = {
+    bindingName: containerBindingName(exportName),
+    className: containerClassName(exportName),
+    exportName,
+    image: { buildContext: ".", dockerfilePath: "./Dockerfile", kind: "dockerfile" }
+  };
+  let sawImage = false;
+  for (const property of argument.getProperties()) {
+    if (!Node.isPropertyAssignment(property)) {
+      continue;
+    }
+    const key = property.getName();
+    const initializer = property.getInitializerOrThrow();
+    switch (key) {
+      case "buildArgs": {
+        ir.buildArgs = stringRecordLiteral(initializer);
+        break;
+      }
+      case "enableInternet": {
+        ir.enableInternet = booleanLiteral(initializer);
+        break;
+      }
+      case "image": {
+        ir.image = imageFromExpression(initializer, exportName);
+        sawImage = true;
+        break;
+      }
+      case "instanceType": {
+        ir.instanceType = instanceTypeFromExpression(initializer, exportName);
+        break;
+      }
+      case "maxInstances": {
+        ir.maxInstances = numberProperty(initializer, exportName, "maxInstances");
+        break;
+      }
+      case "name": {
+        ir.name = stringProperty(initializer, exportName, "name");
+        break;
+      }
+      case "rollout": {
+        ir.rollout = rolloutLiteral(initializer);
+        break;
+      }
+      case "sleepAfter": {
+        ir.sleepAfter = stringOrNumberLiteral(initializer);
+        break;
+      }
+    }
+  }
+  if (!sawImage) {
+    throw diagnosticAt(argument, `container "${exportName}": defineContainer requires a static \`image\` property`);
+  }
+  return ir;
+};
+const containersFromSource = (source) => {
+  const containers = [];
+  for (const declaration of source.getVariableDeclarations()) {
+    if (!declaration.isExported()) {
+      continue;
+    }
+    const initializer = declaration.getInitializer();
+    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
+      continue;
+    }
+    const call = initializer;
+    const callee = call.getExpression();
+    if (!Node.isIdentifier(callee) || !isDefineContainer(callee)) {
+      continue;
+    }
+    const nameNode = declaration.getNameNode();
+    if (!Node.isIdentifier(nameNode)) {
+      throw diagnosticAt(nameNode, "defineContainer exports must be plain named exports (no destructuring)");
+    }
+    containers.push(containerFromCall(call, nameNode.getText()));
+  }
+  return containers;
+};
+const discoverContainers = (project, lunoraDirectory) => {
+  const containersPath = join(lunoraDirectory, CONTAINERS_FILENAME);
+  if (!existsSync(containersPath)) {
+    return [];
+  }
+  const source = project.getSourceFile(containersPath) ?? project.addSourceFileAtPath(containersPath);
+  const containers = containersFromSource(source);
+  containers.sort((a, b) => a.exportName.localeCompare(b.exportName));
+  return containers;
+};
+
+export { CONTAINERS_FILENAME, discoverContainers };

package/dist/packem_shared/CodegenDiagnosticError-DeblMkzO.mjs

@@ -0,0 +1,23 @@
+class CodegenDiagnosticError extends Error {
+  column;
+  file;
+  line;
+  constructor(message, file, line, column) {
+    super(message);
+    this.name = "CodegenDiagnosticError";
+    this.file = file;
+    this.line = line;
+    this.column = column;
+  }
+}
+const diagnosticAt = (node, detail, meta) => {
+  const sourceFile = node.getSourceFile();
+  const file = sourceFile.getFilePath();
+  const line = node.getStartLineNumber();
+  const { column } = sourceFile.getLineAndColumnAtPos(node.getStart());
+  const message = `@lunora/codegen: ${detail} (${file}:${line.toString()}:${column.toString()})`;
+  const error = new CodegenDiagnosticError(message, file, line, column);
+  return meta ? Object.assign(error, meta) : error;
+};
+
+export { CodegenDiagnosticError, diagnosticAt };