@topogram/cli 0.3.34

package/src/generator/surfaces/databases/postgres/sql-schema.js

@@ -0,0 +1,34 @@
+import { generateDbContractGraph } from "../contract.js";
+import { normalizeDbSchemaSnapshot } from "../snapshot.js";
+import {
+  enumStatementsForSnapshot,
+  indexGraphStatements,
+  renderCreateEnumType,
+  renderCreateTable,
+  renderIndexes
+} from "../shared.js";
+import { resolvePostgresCapabilities } from "./capabilities.js";
+
+export function generatePostgresSqlSchema(graph, options = {}) {
+  resolvePostgresCapabilities(options.profileId);
+  const contract = generateDbContractGraph(graph, options);
+  const byId = indexGraphStatements(graph);
+  const snapshot = normalizeDbSchemaSnapshot(contract, byId);
+  const statements = [];
+
+  for (const enumStatement of enumStatementsForSnapshot(snapshot, byId)) {
+    statements.push(renderCreateEnumType(enumStatement));
+    statements.push("");
+  }
+
+  for (const table of snapshot.tables) {
+    statements.push(renderCreateTable(table, "postgres", { byId }));
+    statements.push("");
+    for (const index of renderIndexes(table)) {
+      statements.push(index);
+    }
+    statements.push("");
+  }
+
+  return `${statements.join("\n").trimEnd()}\n`;
+}

package/src/generator/surfaces/databases/shared.d.ts

@@ -0,0 +1 @@
+export function getProjection(graph: any, projectionId?: any): any;

package/src/generator/surfaces/databases/shared.js

@@ -0,0 +1,350 @@
+export const DB_TARGETS = new Set([
+  "db-contract-graph",
+  "db-contract-debug",
+  "db-schema-snapshot",
+  "db-migration-plan",
+  "db-lifecycle-plan",
+  "db-lifecycle-bundle",
+  "sql-schema",
+  "sql-migration",
+  "prisma-schema",
+  "drizzle-schema"
+]);
+
+export function getDbFamily(options = {}) {
+  if (options.projectionId?.includes("sqlite")) {
+    return "sqlite";
+  }
+  return "postgres";
+}
+
+function indexStatements(graph) {
+  const byId = new Map();
+  for (const statement of graph.statements) {
+    byId.set(statement.id, statement);
+  }
+  return byId;
+}
+
+export function getProjection(graph, projectionId) {
+  const byId = indexStatements(graph);
+  const projection = byId.get(projectionId);
+  if (!projection || projection.kind !== "projection") {
+    throw new Error(`No projection found with id '${projectionId}'`);
+  }
+  return projection;
+}
+
+export function indexGraphStatements(graph) {
+  return indexStatements(graph);
+}
+
+export function dbProjectionCandidates(graph) {
+  return (graph.byKind.projection || []).filter(
+    (projection) =>
+      projection.platform?.startsWith("db_") ||
+      (projection.dbTables || []).length > 0 ||
+      (projection.dbColumns || []).length > 0 ||
+      (projection.dbRelations || []).length > 0
+  );
+}
+
+export function defaultTableName(entityId) {
+  const base = entityId.replace(/^entity_/, "");
+  return base.endsWith("s") ? base : `${base}s`;
+}
+
+export function generatorDefaultsMap(projection) {
+  const defaults = {};
+  for (const entry of projection.generatorDefaults || []) {
+    if (entry.key && entry.value != null) {
+      defaults[entry.key] = entry.value;
+    }
+  }
+  return defaults;
+}
+
+export function dbProfileForProjection(projection) {
+  const defaults = generatorDefaultsMap(projection);
+  return defaults.profile || (projection.platform === "db_sqlite" ? "sqlite_sql" : "postgres_sql");
+}
+
+function mergeDbKeys(entity, projection) {
+  const projectionKeys = (projection.dbKeys || []).filter((entry) => entry.entity?.id === entity.id);
+  const baseKeys = entity.keys || [];
+  return [...baseKeys, ...projectionKeys.map((entry) => ({ type: entry.keyType, fields: entry.fields, raw: entry.raw }))];
+}
+
+function mergeDbIndexes(entity, projection) {
+  const projectionIndexes = (projection.dbIndexes || []).filter((entry) => entry.entity?.id === entity.id);
+  const baseIndexes = entity.keys
+    .filter((entry) => entry.type === "index" || entry.type === "unique")
+    .map((entry) => ({ type: entry.type, fields: entry.fields, raw: entry.raw }));
+  return [...baseIndexes, ...projectionIndexes.map((entry) => ({ type: entry.indexType, fields: entry.fields, raw: entry.raw }))];
+}
+
+function dedupeFieldSets(entries) {
+  const seen = new Set();
+  const output = [];
+  for (const entry of entries) {
+    const key = `${entry.type}:${entry.fields.join(",")}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    output.push(entry);
+  }
+  return output;
+}
+
+export function sortFieldSets(fieldSets = []) {
+  return [...fieldSets]
+    .map((fields) => [...fields])
+    .sort((a, b) => a.join("|").localeCompare(b.join("|")));
+}
+
+export function findEnumStatement(byId, typeName) {
+  const candidate = byId.get(typeName);
+  return candidate?.kind === "enum" ? candidate : null;
+}
+
+export function toPascalCase(value) {
+  return value
+    .split(/[_\-\s]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}
+
+export function sqlTypeForField(fieldType, engine, byId = null) {
+  const enumStatement = byId ? findEnumStatement(byId, fieldType) : null;
+  if (enumStatement && engine === "postgres") {
+    return `"${toPascalCase(enumStatement.id.replace(/^enum_/, ""))}"`;
+  }
+  if (engine === "sqlite") {
+    switch (fieldType) {
+      case "integer":
+      case "boolean":
+        return "integer";
+      case "number":
+        return "real";
+      default:
+        return "text";
+    }
+  }
+
+  switch (fieldType) {
+    case "uuid":
+      return "uuid";
+    case "integer":
+      return "integer";
+    case "number":
+      return "double precision";
+    case "boolean":
+      return "boolean";
+    case "datetime":
+      return "timestamptz";
+    default:
+      return "text";
+  }
+}
+
+export function sqlDefaultLiteral(value, fieldType, engine) {
+  if (value == null) {
+    return null;
+  }
+  if (fieldType === "boolean") {
+    return engine === "sqlite" ? (value === "true" ? "1" : "0") : value.toUpperCase();
+  }
+  if (fieldType === "integer" || fieldType === "number") {
+    return value;
+  }
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+export function enumStatementsForSnapshot(snapshot, byId) {
+  if ((snapshot.enums || []).length > 0) {
+    return [...snapshot.enums].sort((a, b) => a.id.localeCompare(b.id));
+  }
+  const enums = new Map();
+  for (const table of snapshot.tables || []) {
+    for (const column of table.columns || []) {
+      const enumStatement = findEnumStatement(byId, column.fieldType);
+      if (enumStatement) {
+        enums.set(enumStatement.id, enumStatement);
+      }
+    }
+  }
+  return [...enums.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+export function renderCreateEnumType(enumStatement) {
+  const typeName = enumStatement.typeName || toPascalCase(enumStatement.id.replace(/^enum_/, ""));
+  const values = enumStatement.values.map((value) => `'${String(value).replace(/'/g, "''")}'`).join(", ");
+  return `DO $$ BEGIN\n  CREATE TYPE "${typeName}" AS ENUM (${values});\nEXCEPTION\n  WHEN duplicate_object THEN null;\nEND $$;`;
+}
+
+export function renderAddEnumValue(enumStatement, operation) {
+  const typeName = enumStatement.typeName || toPascalCase(enumStatement.id.replace(/^enum_/, ""));
+  const escapedValue = `'${String(operation.value).replace(/'/g, "''")}'`;
+  const position =
+    operation.before != null
+      ? ` BEFORE '${String(operation.before).replace(/'/g, "''")}'`
+      : operation.after != null
+        ? ` AFTER '${String(operation.after).replace(/'/g, "''")}'`
+        : "";
+  return `ALTER TYPE "${typeName}" ADD VALUE IF NOT EXISTS ${escapedValue}${position};`;
+}
+
+export function renderCreateTable(table, engine, options = {}) {
+  const includeRelations = options.includeRelations !== false;
+  const byId = options.byId || null;
+  const lines = [];
+  for (const column of table.columns) {
+    const parts = [`${column.name} ${sqlTypeForField(column.fieldType, engine, byId)}`];
+    if (column.requiredness === "required") {
+      parts.push("not null");
+    }
+    const defaultLiteral = sqlDefaultLiteral(column.defaultValue, column.fieldType, engine);
+    if (defaultLiteral != null) {
+      parts.push(`default ${defaultLiteral}`);
+    }
+    lines.push(`  ${parts.join(" ")}`);
+  }
+
+  if (table.primaryKey.length > 0) {
+    lines.push(`  primary key (${table.primaryKey.join(", ")})`);
+  }
+  for (const fields of table.uniques) {
+    lines.push(`  unique (${fields.join(", ")})`);
+  }
+  if (includeRelations) {
+    for (const relation of table.relations) {
+      if (relation.target?.id && relation.target?.field) {
+        const targetTable = defaultTableName(relation.target.id);
+        lines.push(`  foreign key (${relation.field}) references ${targetTable}(${relation.target.field})${relation.onDelete ? ` on delete ${relation.onDelete.replace("_", " ")}` : ""}`);
+      }
+    }
+  }
+
+  return `create table ${table.table} (\n${lines.join(",\n")}\n);`;
+}
+
+export function renderIndexes(table) {
+  return table.indexes
+    .filter((entry) => entry.type === "index")
+    .map((entry) => {
+      const name = `${table.table}_${entry.fields.join("_")}_${entry.type}`;
+      return `create index ${name} on ${table.table} (${entry.fields.join(", ")});`;
+    });
+}
+
+export function renderAddColumn(table, column) {
+  const parts = [`alter table ${table} add column ${column.name} ${column.dbType}`];
+  if (column.required) {
+    parts.push("not null");
+  }
+  if (column.defaultSql != null) {
+    parts.push(`default ${column.defaultSql}`);
+  }
+  return `${parts.join(" ")};`;
+}
+
+export function buildDbProjectionContract(graph, projection) {
+  const byId = indexStatements(graph);
+  const realizedEntities = (projection.realizes || [])
+    .map((ref) => byId.get(ref.id))
+    .filter((statement) => statement?.kind === "entity");
+
+  const tableMappings = new Map((projection.dbTables || []).map((entry) => [entry.entity?.id, entry.table]));
+  const columnMappings = new Map((projection.dbColumns || []).map((entry) => [`${entry.entity?.id}:${entry.field}`, entry.column]));
+  const relationMappings = new Map();
+  for (const entry of projection.dbRelations || []) {
+    if (!relationMappings.has(entry.entity?.id)) {
+      relationMappings.set(entry.entity?.id, []);
+    }
+    relationMappings.get(entry.entity?.id).push(entry);
+  }
+  const lifecycleMappings = new Map();
+  for (const entry of projection.dbLifecycle || []) {
+    if (!lifecycleMappings.has(entry.entity?.id)) {
+      lifecycleMappings.set(entry.entity?.id, []);
+    }
+    lifecycleMappings.get(entry.entity?.id).push(entry);
+  }
+
+  return {
+    projection: {
+      id: projection.id,
+      name: projection.name || projection.id,
+      platform: projection.platform
+    },
+    profile: dbProfileForProjection(projection),
+    generatorDefaults: generatorDefaultsMap(projection),
+    tables: realizedEntities.map((entity) => {
+      const tableName = tableMappings.get(entity.id) || defaultTableName(entity.id);
+      const mergedKeys = mergeDbKeys(entity, projection);
+      const mergedIndexes = dedupeFieldSets(mergeDbIndexes(entity, projection));
+      const primaryKey = mergedKeys.find((entry) => entry.type === "primary")?.fields || [];
+      const uniques = mergedKeys
+        .filter((entry) => entry.type === "unique")
+        .map((entry) => entry.fields);
+      const indexes = mergedIndexes
+        .filter((entry) => entry.type === "index" || entry.type === "unique")
+        .map((entry) => ({
+          type: entry.type,
+          fields: entry.fields
+        }));
+      const relationEntries = relationMappings.get(entity.id) || entity.relations.map((relation) => ({
+        field: relation.sourceField,
+        target: relation.target,
+        onDelete: null
+      }));
+      const lifecycleEntries = lifecycleMappings.get(entity.id) || [];
+
+      return {
+        type: "db_table_contract",
+        entity: {
+          id: entity.id,
+          name: entity.name || entity.id
+        },
+        table: tableName,
+        columns: entity.fields.map((field) => ({
+          name: columnMappings.get(`${entity.id}:${field.name}`) || field.name,
+          sourceField: field.name,
+          fieldType: field.fieldType,
+          requiredness: field.requiredness,
+          defaultValue: field.defaultValue
+        })),
+        primaryKey,
+        uniques,
+        indexes,
+        relations: relationEntries.map((entry) => ({
+          field: entry.field || entry.sourceField,
+          target: entry.target,
+          onDelete: entry.onDelete || null
+        })),
+        lifecycle: {
+          softDelete: (() => {
+            const entry = lifecycleEntries.find((item) => item.lifecycleType === "soft_delete");
+            return entry
+              ? {
+                  field: entry.field,
+                  value: entry.value
+                }
+              : null;
+          })(),
+          timestamps: (() => {
+            const entry = lifecycleEntries.find((item) => item.lifecycleType === "timestamps");
+            return entry
+              ? {
+                  createdAt: entry.createdAt,
+                  updatedAt: entry.updatedAt
+                }
+              : null;
+          })()
+        }
+      };
+    })
+  };
+}

package/src/generator/surfaces/databases/snapshot.js

@@ -0,0 +1,96 @@
+import {
+  buildDbProjectionContract,
+  dbProjectionCandidates,
+  findEnumStatement,
+  getProjection,
+  indexGraphStatements,
+  sortFieldSets,
+  sqlDefaultLiteral,
+  sqlTypeForField,
+  toPascalCase
+} from "./shared.js";
+
+export function normalizeDbSchemaSnapshot(contract, byId = null) {
+  const engine = contract.projection.platform === "db_sqlite" ? "sqlite" : "postgres";
+  const tables = [...contract.tables]
+    .map((table) => ({
+      table: table.table,
+      entity: table.entity,
+      columns: [...table.columns]
+        .map((column) => ({
+          name: column.name,
+          sourceField: column.sourceField,
+          fieldType: column.fieldType,
+          dbType: sqlTypeForField(column.fieldType, engine, byId),
+          required: column.requiredness === "required",
+          requiredness: column.requiredness,
+          defaultValue: column.defaultValue ?? null,
+          defaultSql: sqlDefaultLiteral(column.defaultValue, column.fieldType, engine)
+        }))
+        .sort((a, b) => a.name.localeCompare(b.name)),
+      primaryKey: [...table.primaryKey],
+      uniques: sortFieldSets(table.uniques || []),
+      indexes: [...(table.indexes || [])]
+        .map((entry) => ({
+          type: entry.type,
+          fields: [...entry.fields]
+        }))
+        .sort((a, b) => `${a.type}:${a.fields.join("|")}`.localeCompare(`${b.type}:${b.fields.join("|")}`)),
+      relations: [...(table.relations || [])]
+        .map((relation) => ({
+          field: relation.field,
+          target: relation.target,
+          onDelete: relation.onDelete || null
+        }))
+        .sort((a, b) => `${a.field}:${a.target?.id || ""}:${a.target?.field || ""}`.localeCompare(`${b.field}:${b.target?.id || ""}:${b.target?.field || ""}`)),
+      lifecycle: table.lifecycle
+    }))
+    .sort((a, b) => a.table.localeCompare(b.table));
+  const enums = byId
+    ? [...new Map(
+        tables.flatMap((table) =>
+          table.columns.flatMap((column) => {
+            const enumStatement = findEnumStatement(byId, column.fieldType);
+            if (!enumStatement) {
+              return [];
+            }
+            return [[
+              enumStatement.id,
+              {
+                id: enumStatement.id,
+                typeName: toPascalCase(enumStatement.id.replace(/^enum_/, "")),
+                values: [...enumStatement.values]
+              }
+            ]];
+          })
+        )
+      ).values()].sort((a, b) => a.id.localeCompare(b.id))
+    : [];
+
+  return {
+    type: "db_schema_snapshot",
+    projection: contract.projection,
+    profile: contract.profile,
+    generatorDefaults: contract.generatorDefaults,
+    engine,
+    enums,
+    tables
+  };
+}
+
+export function getTableFromSnapshot(snapshot, tableName) {
+  return (snapshot.tables || []).find((table) => table.table === tableName);
+}
+
+export function generateDbSchemaSnapshot(graph, options = {}) {
+  const byId = indexGraphStatements(graph);
+  if (options.projectionId) {
+    return normalizeDbSchemaSnapshot(buildDbProjectionContract(graph, getProjection(graph, options.projectionId)), byId);
+  }
+
+  const output = {};
+  for (const projection of dbProjectionCandidates(graph)) {
+    output[projection.id] = normalizeDbSchemaSnapshot(buildDbProjectionContract(graph, projection), byId);
+  }
+  return output;
+}

package/src/generator/surfaces/databases/sqlite/capabilities.js

@@ -0,0 +1,14 @@
+export const SQLITE_CAPABILITIES = {
+  default: {
+    family: "sqlite",
+    profiles: ["default"],
+    supportsEnums: false,
+    supportsPrisma: true,
+    supportsDrizzle: false,
+    supportsGeneratedBundles: true
+  }
+};
+
+export function resolveSqliteCapabilities(profileId = "default") {
+  return SQLITE_CAPABILITIES[profileId] || SQLITE_CAPABILITIES.default;
+}

package/src/generator/surfaces/databases/sqlite/index.js

@@ -0,0 +1,8 @@
+export { resolveSqliteCapabilities } from "./capabilities.js";
+export { generateSqlitePrismaSchema } from "./prisma.js";
+export { generateSqliteSqlSchema } from "./sql-schema.js";
+export { generateSqliteSqlMigration } from "./sql-migration.js";
+export {
+  generateSqliteDbLifecycleBundle,
+  generateSqliteDbLifecyclePlan
+} from "./lifecycle.js";

package/src/generator/surfaces/databases/sqlite/lifecycle.js

@@ -0,0 +1,16 @@
+import {
+  generateDbLifecycleBundleForProjection,
+  generateDbLifecyclePlanForProjection
+} from "../lifecycle-shared.js";
+import { getProjection } from "../shared.js";
+import { resolveSqliteCapabilities } from "./capabilities.js";
+
+export function generateSqliteDbLifecyclePlan(graph, options = {}) {
+  resolveSqliteCapabilities(options.profileId);
+  return generateDbLifecyclePlanForProjection(graph, getProjection(graph, options.projectionId), options);
+}
+
+export function generateSqliteDbLifecycleBundle(graph, options = {}) {
+  resolveSqliteCapabilities(options.profileId);
+  return generateDbLifecycleBundleForProjection(graph, getProjection(graph, options.projectionId), options);
+}

package/src/generator/surfaces/databases/sqlite/prisma.js

@@ -0,0 +1,143 @@
+import {
+  buildDbProjectionContract,
+  defaultTableName,
+  findEnumStatement,
+  getProjection,
+  indexGraphStatements,
+  toPascalCase
+} from "../shared.js";
+import { normalizeDbSchemaSnapshot } from "../snapshot.js";
+import { resolveSqliteCapabilities } from "./capabilities.js";
+
+function prismaScalarForColumn(column, byId) {
+  const enumStatement = findEnumStatement(byId, column.fieldType);
+  if (enumStatement) {
+    return { type: "String" };
+  }
+
+  switch (column.fieldType) {
+    case "integer":
+      return { type: "Int" };
+    case "number":
+      return { type: "Float" };
+    case "boolean":
+      return { type: "Boolean" };
+    case "datetime":
+      return { type: "DateTime" };
+    default:
+      return { type: "String" };
+  }
+}
+
+function prismaDefaultForColumn(column) {
+  if (column.defaultValue == null) {
+    return null;
+  }
+  if (column.fieldType === "boolean") {
+    return `@default(${String(column.defaultValue) === "true" ? "true" : "false"})`;
+  }
+  if (column.fieldType === "integer" || column.fieldType === "number") {
+    return `@default(${column.defaultValue})`;
+  }
+  return `@default("${String(column.defaultValue).replace(/"/g, '\\"')}")`;
+}
+
+export function generateSqlitePrismaSchema(graph, options = {}) {
+  resolveSqliteCapabilities(options.profileId);
+  const projection = getProjection(graph, options.projectionId);
+  if (projection.platform !== "db_sqlite") {
+    throw new Error(`Prisma schema generation currently supports db_sqlite projections only, found '${projection.platform}'`);
+  }
+
+  const byId = indexGraphStatements(graph);
+  const snapshot = normalizeDbSchemaSnapshot(buildDbProjectionContract(graph, projection));
+
+  const relationBackrefs = new Map();
+  for (const table of snapshot.tables) {
+    for (const relation of table.relations || []) {
+      const targetTable = defaultTableName(relation.target.id);
+      if (!relationBackrefs.has(targetTable)) {
+        relationBackrefs.set(targetTable, []);
+      }
+      relationBackrefs.get(targetTable).push({
+        fromTable: table.table,
+        fromModel: toPascalCase(table.entity.id.replace(/^entity_/, "")),
+        field: relation.field,
+        relationName: `${toPascalCase(table.entity.id.replace(/^entity_/, ""))}_${relation.field}_to_${toPascalCase(relation.target.id.replace(/^entity_/, ""))}`
+      });
+    }
+  }
+
+  const lines = [];
+  lines.push('generator client {');
+  lines.push('  provider = "prisma-client-js"');
+  lines.push("}");
+  lines.push("");
+  lines.push("datasource db {");
+  lines.push('  provider = "sqlite"');
+  lines.push('  url      = env("DATABASE_URL")');
+  lines.push("}");
+  lines.push("");
+
+  for (const table of snapshot.tables) {
+    const modelName = toPascalCase(table.entity.id.replace(/^entity_/, ""));
+    const pk = table.primaryKey || [];
+    const relationFields = new Map((table.relations || []).map((entry) => [entry.field, entry]));
+
+    lines.push(`model ${modelName} {`);
+    for (const column of table.columns) {
+      const scalar = prismaScalarForColumn(column, byId);
+      const optional = column.required ? "" : "?";
+      const attrs = [];
+      if (pk.length === 1 && pk[0] === column.name) {
+        attrs.push("@id");
+      }
+      const uniqueMatch = (table.uniques || []).find((fields) => fields.length === 1 && fields[0] === column.name);
+      if (uniqueMatch) {
+        attrs.push("@unique");
+      }
+      const defaultAttr = prismaDefaultForColumn(column);
+      if (defaultAttr) {
+        attrs.push(defaultAttr);
+      }
+      if (column.name !== column.sourceField) {
+        attrs.push(`@map("${column.name}")`);
+      }
+      lines.push(`  ${column.sourceField} ${scalar.type}${optional}${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}`);
+
+      const relation = relationFields.get(column.name);
+      if (relation) {
+        const targetModel = toPascalCase(relation.target.id.replace(/^entity_/, ""));
+        const relationName = `${modelName}_${column.sourceField}_to_${targetModel}`;
+        const optionalRelation = column.required ? "" : "?";
+        lines.push(`  ${column.sourceField.replace(/_id$/, "")} ${targetModel}${optionalRelation} @relation("${relationName}", fields: [${column.sourceField}], references: [${relation.target.field}])`);
+      }
+    }
+
+    for (const backref of relationBackrefs.get(table.table) || []) {
+      const relationFieldName = `${backref.fromTable}`;
+      lines.push(`  ${relationFieldName} ${backref.fromModel}[] @relation("${backref.relationName}")`);
+    }
+
+    if (pk.length > 1) {
+      lines.push(`  @@id([${pk.join(", ")}])`);
+    }
+    for (const fields of table.uniques || []) {
+      if (fields.length > 1) {
+        lines.push(`  @@unique([${fields.join(", ")}])`);
+      }
+    }
+    for (const index of table.indexes || []) {
+      if (index.type === "index") {
+        lines.push(`  @@index([${index.fields.join(", ")}])`);
+      }
+    }
+    if (table.table !== modelName) {
+      lines.push(`  @@map("${table.table}")`);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+
+  return `${lines.join("\n").trimEnd()}\n`;
+}