@lunora/codegen 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/buildSchemaSnapshot-DzLDbWk3.mjs

@@ -0,0 +1,233 @@
+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 = {};
+  for (const key of Object.keys(record).toSorted((a, b) => a.localeCompare(b))) {
+    sorted[key] = record[key];
+  }
+  return sorted;
+};
+const buildSchemaSnapshot = (schema, migrationIds) => {
+  const tables = {};
+  for (const table of schema.tables) {
+    tables[table.name] = tableSnapshotOf(table);
+  }
+  return {
+    migrationIds: [...migrationIds].toSorted((a, b) => a.localeCompare(b)),
+    tables: sortKeys(tables),
+    version: SCHEMA_SNAPSHOT_VERSION
+  };
+};
+const serializeSchemaSnapshot = (snapshot) => `${JSON.stringify(snapshot, void 0, 2)}
+`;
+class SchemaSnapshotParseError extends Error {
+  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`);
+    }
+  }
+  return {
+    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"
+      });
+    }
+  }
+  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 };