@lunora/codegen 1.0.0-alpha.55 → 1.0.0-alpha.56

package/dist/packem_shared/SCHEMA_SNAPSHOT_VERSION-DGD73E_n.mjs

@@ -1,252 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const SCHEMA_SNAPSHOT_VERSION = 1;
-const encodeShardMode = (mode) => {
-  if (mode === "global" || mode === "root") {
-    return mode;
-  }
-  return `shardBy:${mode.field}`;
-};
-const fieldSnapshotOf = (validator) => {
-  if (validator.kind === "optional") {
-    return { kind: validator.inner?.kind ?? "unknown", optional: true };
-  }
-  return { kind: validator.kind, optional: false };
-};
-const tableSnapshotOf = (table) => {
-  const fields = {};
-  for (const [name, validator] of Object.entries(table.shape)) {
-    fields[name] = fieldSnapshotOf(validator);
-  }
-  const indexes = {};
-  for (const index of table.indexes) {
-    indexes[index.name] = { fields: [...index.fields], unique: index.unique ?? false };
-  }
-  const relations = {};
-  for (const relation of table.relations) {
-    relations[relation.name] = { field: relation.field, kind: relation.kind, table: relation.table };
-  }
-  return { fields, indexes, relations, shardMode: encodeShardMode(table.shardMode) };
-};
-const sortKeys = (record) => {
-  const sorted = {};
-  const keys = Object.keys(record);
-  keys.sort();
-  for (const key of keys) {
-    sorted[key] = record[key];
-  }
-  return sorted;
-};
-const buildSchemaSnapshot = (schema, migrationIds) => {
-  const tables = {};
-  for (const table of schema.tables) {
-    tables[table.name] = tableSnapshotOf(table);
-  }
-  const sortedMigrationIds = [...migrationIds].sort();
-  return {
-    jurisdiction: schema.jurisdiction,
-    migrationIds: sortedMigrationIds,
-    tables: sortKeys(tables),
-    version: SCHEMA_SNAPSHOT_VERSION
-  };
-};
-const serializeSchemaSnapshot = (snapshot) => `${JSON.stringify(snapshot, void 0, 2)}
-`;
-class SchemaSnapshotParseError extends LunoraError {
-  constructor(message) {
-    super("SCHEMA_SNAPSHOT_PARSE", message, { name: "SchemaSnapshotParseError" });
-  }
-}
-const isRecord = (value) => typeof value === "object" && value !== null;
-const isValidTableSnapshot = (value) => isRecord(value) && isRecord(value.fields) && isRecord(value.indexes) && isRecord(value.relations) && typeof value.shardMode === "string";
-const parseSchemaSnapshot = (content) => {
-  if (content === void 0 || content.trim() === "") {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch (error) {
-    throw new SchemaSnapshotParseError(`baseline is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  if (!isRecord(parsed) || parsed.version !== SCHEMA_SNAPSHOT_VERSION || !isRecord(parsed.tables)) {
-    throw new SchemaSnapshotParseError(`baseline is malformed or written by an incompatible version (expected version ${String(SCHEMA_SNAPSHOT_VERSION)})`);
-  }
-  for (const [name, table] of Object.entries(parsed.tables)) {
-    if (!isValidTableSnapshot(table)) {
-      throw new SchemaSnapshotParseError(`baseline table "${name}" has an invalid structure`);
-    }
-  }
-  const jurisdiction = typeof parsed.jurisdiction === "string" ? parsed.jurisdiction : void 0;
-  return {
-    jurisdiction,
-    migrationIds: Array.isArray(parsed.migrationIds) ? parsed.migrationIds : [],
-    tables: parsed.tables,
-    version: SCHEMA_SNAPSHOT_VERSION
-  };
-};
-const indexesEqual = (a, b) => a.unique === b.unique && a.fields.length === b.fields.length && a.fields.every((field, index) => field === b.fields[index]);
-const diffExistingField = (tableName, name, old, field) => {
-  const changes = [];
-  if (old.kind !== field.kind) {
-    changes.push({
-      severity: "breaking",
-      summary: `field ${tableName}.${name} changed type: ${old.kind} → ${field.kind} — add a data migration to convert existing values`,
-      type: "changedFieldKind"
-    });
-  }
-  if (old.optional && !field.optional) {
-    changes.push({
-      severity: "breaking",
-      summary: `field ${tableName}.${name} became required — rows missing it would be invalid; add a data migration to backfill it`,
-      type: "fieldOptionalToRequired"
-    });
-  } else if (!old.optional && field.optional) {
-    changes.push({ severity: "safe", summary: `field ${tableName}.${name} became optional`, type: "fieldRequiredToOptional" });
-  }
-  return changes;
-};
-const addedFieldChange = (tableName, name, field) => field.optional ? { severity: "safe", summary: `added optional field ${tableName}.${name}`, type: "addedOptionalField" } : {
-  severity: "breaking",
-  summary: `added required field ${tableName}.${name} — existing rows have no value; add a data migration to backfill it`,
-  type: "addedRequiredField"
-};
-const diffFields = (tableName, baseline, current, changes) => {
-  for (const [name, field] of Object.entries(current.fields)) {
-    const old = baseline.fields[name];
-    if (old === void 0) {
-      changes.push(addedFieldChange(tableName, name, field));
-    } else {
-      changes.push(...diffExistingField(tableName, name, old, field));
-    }
-  }
-  for (const name of Object.keys(baseline.fields)) {
-    if (current.fields[name] === void 0) {
-      changes.push({
-        severity: "breaking",
-        summary: `removed field ${tableName}.${name} — add a data migration if stored data must be cleaned up`,
-        type: "removedField"
-      });
-    }
-  }
-};
-const diffIndexes = (tableName, baseline, current, changes) => {
-  for (const [name, index] of Object.entries(current.indexes)) {
-    const old = baseline.indexes[name];
-    if (old === void 0) {
-      changes.push({ severity: "safe", summary: `added index ${name} on ${tableName}`, type: "addedIndex" });
-      continue;
-    }
-    if (!indexesEqual(old, index)) {
-      changes.push({
-        severity: "breaking",
-        summary: `index ${name} on ${tableName} changed shape — a query may have relied on the old index`,
-        type: "changedIndex"
-      });
-    }
-  }
-  for (const name of Object.keys(baseline.indexes)) {
-    if (current.indexes[name] === void 0) {
-      changes.push({
-        severity: "breaking",
-        summary: `removed index ${name} on ${tableName} — a query that used \`.withIndex("${name}")\` would break`,
-        type: "removedIndex"
-      });
-    }
-  }
-};
-const diffRelations = (tableName, baseline, current, changes) => {
-  for (const name of Object.keys(current.relations)) {
-    if (baseline.relations[name] === void 0) {
-      changes.push({ severity: "safe", summary: `added relation ${tableName}.${name}`, type: "addedRelation" });
-    }
-  }
-  for (const name of Object.keys(baseline.relations)) {
-    if (current.relations[name] === void 0) {
-      changes.push({ severity: "breaking", summary: `removed relation ${tableName}.${name}`, type: "removedRelation" });
-    }
-  }
-};
-const diffExistingTable = (tableName, baseline, current, changes) => {
-  if (baseline.shardMode !== current.shardMode) {
-    changes.push({
-      severity: "breaking",
-      summary: `table ${tableName} changed shard mode: ${baseline.shardMode} → ${current.shardMode} — its physical storage moves; add a data migration / re-shard plan`,
-      type: "changedShardMode"
-    });
-  }
-  diffFields(tableName, baseline, current, changes);
-  diffIndexes(tableName, baseline, current, changes);
-  diffRelations(tableName, baseline, current, changes);
-};
-const diffSchemaSnapshots = (baseline, current) => {
-  const changes = [];
-  const baselineTables = baseline?.tables ?? {};
-  for (const [tableName, table] of Object.entries(current.tables)) {
-    const old = baselineTables[tableName];
-    if (old === void 0) {
-      changes.push({ severity: "safe", summary: `added table ${tableName}`, type: "addedTable" });
-      continue;
-    }
-    diffExistingTable(tableName, old, table, changes);
-  }
-  for (const tableName of Object.keys(baselineTables)) {
-    if (current.tables[tableName] === void 0) {
-      changes.push({
-        severity: "breaking",
-        summary: `removed table ${tableName} — add a data migration if its data must be archived/cleaned up`,
-        type: "removedTable"
-      });
-    }
-  }
-  if (baseline !== void 0 && baseline.jurisdiction !== current.jurisdiction) {
-    const from = baseline.jurisdiction ?? "(none)";
-    const to = current.jurisdiction ?? "(none)";
-    changes.push({
-      severity: "breaking",
-      summary: `Durable Object jurisdiction changed from ${from} to ${to} — this re-homes every DO and strands all existing shard, scheduler, and session-DO data in the old region (no in-place migration; export then import to move it). Revert the change, or override the gate to proceed intentionally.`,
-      type: "changedJurisdiction"
-    });
-  }
-  return { changes };
-};
-const evaluateSchemaDrift = (options) => {
-  const { allowDrift = false, baseline, current } = options;
-  const drift = diffSchemaSnapshots(baseline, current);
-  const breaking = drift.changes.filter((change) => change.severity === "breaking");
-  const newMigrationIds = current.migrationIds.filter((id) => !(baseline?.migrationIds ?? []).includes(id));
-  if (drift.changes.length === 0 || baseline === void 0) {
-    return { blocked: false, changes: drift.changes, newMigrationIds, reason: "" };
-  }
-  if (breaking.length === 0) {
-    const summary = drift.changes.map((change) => `  - ${change.summary}`).join("\n");
-    return { blocked: false, changes: drift.changes, newMigrationIds, reason: `schema drift detected (all additive/safe):
-${summary}` };
-  }
-  const breakingSummary = breaking.map((change) => `  - ${change.summary}`).join("\n");
-  if (newMigrationIds.length > 0) {
-    return {
-      blocked: false,
-      changes: drift.changes,
-      newMigrationIds,
-      reason: `breaking schema drift detected, but ${String(newMigrationIds.length)} new migration(s) were added (${newMigrationIds.join(", ")}):
-${breakingSummary}`
-    };
-  }
-  const reason = `deploy blocked: ${String(breaking.length)} breaking schema change(s) detected since the last blessed schema baseline — these changes are incompatible with existing data without a migration:
-${breakingSummary}
-
-To fix:
-  • For breaking changes: add a \`defineMigration({ id, table, up })\` in lunora/ for each affected table, then run \`lunora migrate\` (or \`lunora codegen\`) to apply and re-bless the baseline.
-  • For backward-compatible changes (e.g. adding an optional field): pass \`--allow-schema-drift\` to skip the block.
-  • To accept the new shape without a migration (you know data is compatible): pass \`--update-schema-baseline\`.
-Docs: https://lunora.dev/docs/migrations`;
-  if (allowDrift) {
-    return { blocked: false, changes: drift.changes, newMigrationIds, reason: `${reason}
-
-(overridden by --allow-schema-drift)` };
-  }
-  return { blocked: true, changes: drift.changes, newMigrationIds, reason };
-};
-
-export { SCHEMA_SNAPSHOT_VERSION, SchemaSnapshotParseError, buildSchemaSnapshot, diffSchemaSnapshots, evaluateSchemaDrift, parseSchemaSnapshot, serializeSchemaSnapshot };

package/dist/packem_shared/SHAPES_FILENAME-DOhPGi-6.mjs

@@ -1,94 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { SyntaxKind, Node } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
-
-const SHAPES_FILENAME = "shapes.ts";
-const SHAPE_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["@lunora/server", "lunorash/server"]);
-const isDefineShape = (identifier) => {
-  const symbol = identifier.getSymbol();
-  if (!symbol) {
-    return identifier.getText() === "defineShape";
-  }
-  for (const declaration of symbol.getDeclarations()) {
-    if (!Node.isImportSpecifier(declaration)) {
-      continue;
-    }
-    if (!SHAPE_MODULE_SPECIFIERS.has(declaration.getImportDeclaration().getModuleSpecifierValue())) {
-      return false;
-    }
-    return declaration.getNameNode().getText() === "defineShape";
-  }
-  return false;
-};
-const isShapeNamespaceImport = (identifier) => {
-  const symbol = identifier.getSymbol();
-  if (!symbol) {
-    return false;
-  }
-  for (const declaration of symbol.getDeclarations()) {
-    if (!Node.isNamespaceImport(declaration)) {
-      continue;
-    }
-    const importDeclaration = declaration.getFirstAncestorByKind(SyntaxKind.ImportDeclaration);
-    return importDeclaration !== void 0 && SHAPE_MODULE_SPECIFIERS.has(importDeclaration.getModuleSpecifierValue());
-  }
-  return false;
-};
-const isDefineShapeCallee = (callee) => {
-  if (Node.isIdentifier(callee)) {
-    return isDefineShape(callee);
-  }
-  if (Node.isPropertyAccessExpression(callee)) {
-    const object = callee.getExpression();
-    return callee.getName() === "defineShape" && Node.isIdentifier(object) && isShapeNamespaceImport(object);
-  }
-  return false;
-};
-const tableLiteralFrom = (call) => {
-  const [config] = call.getArguments();
-  if (!config || !Node.isObjectLiteralExpression(config)) {
-    return void 0;
-  }
-  const tableProperty = config.getProperty("table");
-  if (!tableProperty || !Node.isPropertyAssignment(tableProperty)) {
-    return void 0;
-  }
-  const value = tableProperty.getInitializer();
-  return value && Node.isStringLiteral(value) ? value.getLiteralValue() : void 0;
-};
-const shapesFromSource = (source) => {
-  const shapes = [];
-  for (const declaration of source.getVariableDeclarations()) {
-    if (!declaration.isExported()) {
-      continue;
-    }
-    const initializer = declaration.getInitializer();
-    if (initializer?.getKind() !== SyntaxKind.CallExpression) {
-      continue;
-    }
-    const callExpression = initializer;
-    const callee = callExpression.getExpression();
-    if (!isDefineShapeCallee(callee)) {
-      continue;
-    }
-    const nameNode = declaration.getNameNode();
-    if (!Node.isIdentifier(nameNode)) {
-      throw diagnosticAt(nameNode, "defineShape exports must be plain named exports (no destructuring)");
-    }
-    shapes.push({ exportName: nameNode.getText(), filePath: "shapes", table: tableLiteralFrom(callExpression) });
-  }
-  return shapes;
-};
-const discoverShapes = (project, lunoraDirectory) => {
-  const shapesPath = join(lunoraDirectory, SHAPES_FILENAME);
-  if (!existsSync(shapesPath)) {
-    return [];
-  }
-  const source = project.getSourceFile(shapesPath) ?? project.addSourceFileAtPath(shapesPath);
-  const shapes = shapesFromSource(source);
-  shapes.sort((a, b) => a.exportName.localeCompare(b.exportName));
-  return shapes;
-};
-
-export { SHAPES_FILENAME, discoverShapes };

package/dist/packem_shared/WORKFLOWS_FILENAME-Dtuzvluc.mjs

@@ -1,158 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { LunoraError } from '@lunora/errors';
-import { workflowDefaultName, workflowClassName, workflowBindingName } from '@lunora/workflow';
-import { Node, SyntaxKind } from 'ts-morph';
-import { diagnosticAt } from './CodegenDiagnosticError-DyQ5FwkM.mjs';
-
-const WORKFLOWS_FILENAME = "workflows.ts";
-const STEP_METHODS = /* @__PURE__ */ new Set(["do", "sleep", "sleepUntil", "waitForEvent"]);
-const isDefineWorkflow = (identifier) => {
-  const symbol = identifier.getSymbol();
-  if (!symbol) {
-    return identifier.getText() === "defineWorkflow";
-  }
-  for (const declaration of symbol.getDeclarations()) {
-    if (!Node.isImportSpecifier(declaration)) {
-      continue;
-    }
-    if (declaration.getImportDeclaration().getModuleSpecifierValue() !== "@lunora/workflow") {
-      return false;
-    }
-    return declaration.getNameNode().getText() === "defineWorkflow";
-  }
-  return false;
-};
-const stringProperty = (expression, exportName, property) => {
-  if (Node.isStringLiteral(expression) || Node.isNoSubstitutionTemplateLiteral(expression)) {
-    return expression.getLiteralValue();
-  }
-  throw diagnosticAt(
-    expression,
-    `workflow "${exportName}": \`${property}\` must be a static string literal — it is deploy configuration codegen writes into wrangler.jsonc`
-  );
-};
-const isStepCall = (call) => {
-  const callee = call.getExpression();
-  if (!Node.isPropertyAccessExpression(callee) || !STEP_METHODS.has(callee.getName())) {
-    return false;
-  }
-  const receiver = callee.getExpression();
-  if (Node.isPropertyAccessExpression(receiver) && receiver.getName() === "step") {
-    return true;
-  }
-  return Node.isIdentifier(receiver) && receiver.getText() === "step";
-};
-const stepsFromHandler = (argument) => {
-  const handlerProperty = argument.getProperty("handler");
-  if (!handlerProperty) {
-    return [];
-  }
-  const body = Node.isPropertyAssignment(handlerProperty) ? handlerProperty.getInitializer() : handlerProperty;
-  if (!body) {
-    return [];
-  }
-  const steps = [];
-  for (const call of body.getDescendantsOfKind(SyntaxKind.CallExpression)) {
-    if (!isStepCall(call)) {
-      continue;
-    }
-    const nameArgument = call.getArguments()[0];
-    if (!nameArgument || !(Node.isStringLiteral(nameArgument) || Node.isNoSubstitutionTemplateLiteral(nameArgument))) {
-      continue;
-    }
-    steps.push({
-      line: call.getStartLineNumber(),
-      // `isStepCall` already proved the callee is a `.<method>` property access.
-      method: call.getExpression().getName(),
-      name: nameArgument.getLiteralValue()
-    });
-  }
-  return steps;
-};
-const workflowFromCall = (call, exportName) => {
-  const argument = call.getArguments()[0];
-  if (!argument || !Node.isObjectLiteralExpression(argument)) {
-    throw diagnosticAt(call, `workflow "${exportName}": defineWorkflow must be passed an inline object literal`);
-  }
-  const ir = {
-    bindingName: workflowBindingName(exportName),
-    className: workflowClassName(exportName),
-    exportName,
-    name: workflowDefaultName(exportName),
-    steps: stepsFromHandler(argument)
-  };
-  const nameProperty = argument.getProperty("name");
-  if (nameProperty && Node.isPropertyAssignment(nameProperty)) {
-    ir.name = stringProperty(nameProperty.getInitializerOrThrow(), exportName, "name");
-  }
-  return ir;
-};
-const unwrapToCallExpression = (node) => {
-  let current = node;
-  while (current && (Node.isAsExpression(current) || Node.isSatisfiesExpression(current) || Node.isParenthesizedExpression(current))) {
-    current = current.getExpression();
-  }
-  return current && Node.isCallExpression(current) ? current : void 0;
-};
-const workflowsFromSource = (source) => {
-  const workflows = [];
-  for (const declaration of source.getVariableDeclarations()) {
-    if (!declaration.isExported()) {
-      continue;
-    }
-    const call = unwrapToCallExpression(declaration.getInitializer());
-    if (!call) {
-      continue;
-    }
-    const callee = call.getExpression();
-    if (!Node.isIdentifier(callee) || !isDefineWorkflow(callee)) {
-      continue;
-    }
-    const nameNode = declaration.getNameNode();
-    if (!Node.isIdentifier(nameNode)) {
-      throw diagnosticAt(nameNode, "defineWorkflow exports must be plain named exports (no destructuring)");
-    }
-    workflows.push(workflowFromCall(call, nameNode.getText()));
-  }
-  return workflows;
-};
-const assertUniqueNames = (workflows) => {
-  const seenNames = /* @__PURE__ */ new Map();
-  const seenBindings = /* @__PURE__ */ new Map();
-  for (const workflow of workflows) {
-    const priorName = seenNames.get(workflow.name);
-    if (priorName !== void 0) {
-      throw new LunoraError(
-        // eslint-disable-next-line no-secrets/no-secrets -- an error code, not a secret
-        "DUPLICATE_WORKFLOW_NAME",
-        `Duplicate workflow name "${workflow.name}": produced by both "${priorName}" and "${workflow.exportName}". Deployed workflow names must be unique across the project.`,
-        { status: 500 }
-      );
-    }
-    seenNames.set(workflow.name, workflow.exportName);
-    const priorBinding = seenBindings.get(workflow.bindingName);
-    if (priorBinding !== void 0) {
-      throw new LunoraError(
-        // eslint-disable-next-line no-secrets/no-secrets -- an error code, not a secret
-        "DUPLICATE_WORKFLOW_BINDING",
-        `Duplicate workflow binding "${workflow.bindingName}": produced by both "${priorBinding}" and "${workflow.exportName}". Workflow export names must yield unique binding names.`,
-        { status: 500 }
-      );
-    }
-    seenBindings.set(workflow.bindingName, workflow.exportName);
-  }
-};
-const discoverWorkflows = (project, lunoraDirectory) => {
-  const workflowsPath = join(lunoraDirectory, WORKFLOWS_FILENAME);
-  if (!existsSync(workflowsPath)) {
-    return [];
-  }
-  const source = project.getSourceFile(workflowsPath) ?? project.addSourceFileAtPath(workflowsPath);
-  const workflows = workflowsFromSource(source);
-  workflows.sort((a, b) => a.exportName.localeCompare(b.exportName));
-  assertUniqueNames(workflows);
-  return workflows;
-};
-
-export { WORKFLOWS_FILENAME, discoverWorkflows };