@prisma-next/target-sqlite 0.14.0-dev.49 → 0.14.0-dev.50

package/src/core/migrations/column-ddl-rendering.ts

@@ -0,0 +1,177 @@
+import type { StorageColumn } from '@prisma-next/sql-contract/types';
+import {
+  DdlColumn,
+  type DdlTableConstraint,
+  ForeignKeyConstraint,
+  FunctionColumnDefault,
+  LiteralColumnDefault,
+  PrimaryKeyConstraint,
+  UniqueConstraint,
+} from '@prisma-next/sql-relational-core/ast';
+import type { SqlColumnIR, SqlTableIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import type { SqliteColumnSpec } from './operations/shared';
+import { buildColumnDefaultSql, buildColumnTypeSql } from './planner-ddl-builders';
+
+/**
+ * Reconstructs the `StorageColumn`-shaped fields `buildColumnTypeSql` /
+ * `buildColumnDefaultSql` expect, from a column node's own stamped codec
+ * identity (`codecRef` / `codecBaseNativeType`, Decision 5) — never the
+ * contract. SQLite's type renderer only uppercases the resolved base type
+ * (no parameterized expansion, no named-type quoting), so `typeRef` is
+ * deliberately left unset here: setting it would send `buildColumnTypeSql`
+ * back through a live `storageTypes` lookup the node's fields have already
+ * resolved past, which throws for an unrecognized reference (unlike
+ * Postgres's lenient fallback).
+ */
+function columnLike(
+  column: SqlColumnIR,
+): Pick<StorageColumn, 'nativeType' | 'codecId' | 'nullable' | 'many' | 'typeParams' | 'default'> {
+  if (column.codecRef === undefined || column.codecBaseNativeType === undefined) {
+    throw new Error(
+      `columnLike: expected column "${column.name}" carries no codec identity — the expected tree must be derived via contractToSchemaIR for planning`,
+    );
+  }
+  return {
+    nativeType: column.codecBaseNativeType,
+    codecId: column.codecRef.codecId,
+    nullable: column.nullable,
+    // `column.many` is unset on contract-derived columns (array-ness rides
+    // on the `nativeType` `[]` suffix there instead) — `codecRef.many`
+    // carries it. Hand-built/introspected columns set `column.many` directly.
+    ...((column.many ?? column.codecRef.many) !== undefined
+      ? { many: column.many ?? column.codecRef.many }
+      : {}),
+    ...(column.codecRef.typeParams !== undefined
+      ? {
+          typeParams: blindCast<
+            Record<string, unknown>,
+            'CodecRef.typeParams is JsonValue-shaped; the DDL builders only ever read it as the Record the contract column originally carried'
+          >(column.codecRef.typeParams),
+        }
+      : {}),
+    ...(column.resolvedDefault !== undefined ? { default: column.resolvedDefault } : {}),
+  };
+}
+
+function sqliteDefaultToDdlColumnDefault(
+  columnDefault: StorageColumn['default'],
+): DdlColumn['default'] {
+  if (!columnDefault) return undefined;
+  switch (columnDefault.kind) {
+    case 'literal':
+      return new LiteralColumnDefault(columnDefault.value);
+    case 'function':
+      // `autoincrement()` is not a DEFAULT clause — SQLite encodes it as
+      // `INTEGER PRIMARY KEY AUTOINCREMENT` inline on the column. Skip it
+      // here; the renderer also has a defensive guard for the same case.
+      if (columnDefault.expression === 'autoincrement()') return undefined;
+      return new FunctionColumnDefault(columnDefault.expression);
+    default: {
+      const exhaustive: never = columnDefault;
+      throw new Error(
+        `sqliteDefaultToDdlColumnDefault: unhandled kind "${blindCast<{ kind: string }, 'exhaustiveness: surface the unhandled default kind'>(exhaustive).kind}"`,
+      );
+    }
+  }
+}
+
+/**
+ * True when the column is rendered inline as `INTEGER PRIMARY KEY
+ * AUTOINCREMENT` — the sole member of the table's primary key with an
+ * `autoincrement()` default. Node-based sibling of the retired
+ * `isInlineAutoincrementPrimaryKey` (which read the raw `StorageTable`);
+ * reads the table/column nodes instead.
+ */
+export function isInlineAutoincrementPrimaryKeyNode(
+  table: SqlTableIR,
+  column: SqlColumnIR,
+): boolean {
+  if (table.primaryKey?.columns.length !== 1) return false;
+  if (table.primaryKey.columns[0] !== column.name) return false;
+  return (
+    column.resolvedDefault?.kind === 'function' &&
+    column.resolvedDefault.expression === 'autoincrement()'
+  );
+}
+
+/**
+ * Builds the flat `SqliteColumnSpec` `AddColumnCall` / `RecreateTableCall`
+ * need, resolved from the column node's codec identity — the same builders
+ * the pre-`plan(start, end)` op-path called, so the output is
+ * byte-identical.
+ */
+export function columnSpecFromNode(column: SqlColumnIR, inline: boolean): SqliteColumnSpec {
+  const like = columnLike(column);
+  const typeSql = buildColumnTypeSql(like, {});
+  const defaultSql = buildColumnDefaultSql(like.default);
+  return {
+    name: column.name,
+    typeSql,
+    defaultSql,
+    nullable: column.nullable,
+    ...(inline ? { inlineAutoincrementPrimaryKey: true } : {}),
+  };
+}
+
+/**
+ * Builds the `DdlColumn` the `CreateTableCall` path needs, resolved from the
+ * column node's codec identity.
+ */
+export function ddlColumnFromNode(column: SqlColumnIR, inline: boolean): DdlColumn {
+  const like = columnLike(column);
+  const typeSql = buildColumnTypeSql(like, {});
+  if (inline) {
+    // `DdlColumn` has no SQLite-specific autoincrement flag, so the full
+    // `PRIMARY KEY AUTOINCREMENT` clause is embedded in the `type` string.
+    // The DDL renderer (`ddl-renderer.ts`) substring-detects `AUTOINCREMENT`
+    // to suppress the normal NOT NULL / PRIMARY KEY / DEFAULT clause rendering
+    // and emit the entire type string verbatim. Both sites must stay in sync.
+    // The structural fix (a SQLite-specific column option) is tracked in TML-2866.
+    return new DdlColumn({ name: column.name, type: `${typeSql} PRIMARY KEY AUTOINCREMENT` });
+  }
+  const colDefault = sqliteDefaultToDdlColumnDefault(like.default);
+  return new DdlColumn({
+    name: column.name,
+    type: typeSql,
+    ...(!column.nullable ? { notNull: true } : {}),
+    ...(colDefault !== undefined ? { default: colDefault } : {}),
+    ...(column.codecRef !== undefined ? { codecRef: column.codecRef } : {}),
+  });
+}
+
+/**
+ * Builds the table-level constraints (PK / unique / FK) for a `CreateTable`
+ * path from the table node — the node-sourced sibling of the retired
+ * contract-based `tableToDdlParts`'s constraint half.
+ */
+export function tableConstraintsFromNode(
+  table: SqlTableIR,
+  hasInlinePk: boolean,
+): DdlTableConstraint[] {
+  const constraints: DdlTableConstraint[] = [];
+  if (table.primaryKey && !hasInlinePk) {
+    constraints.push(new PrimaryKeyConstraint({ columns: table.primaryKey.columns }));
+  }
+  for (const u of table.uniques) {
+    constraints.push(
+      new UniqueConstraint({
+        columns: u.columns,
+        ...(u.name !== undefined ? { name: u.name } : {}),
+      }),
+    );
+  }
+  for (const fk of table.foreignKeys) {
+    constraints.push(
+      new ForeignKeyConstraint({
+        columns: fk.columns,
+        refTable: fk.referencedTable,
+        refColumns: fk.referencedColumns,
+        ...(fk.name !== undefined ? { name: fk.name } : {}),
+        ...(fk.onDelete !== undefined ? { onDelete: fk.onDelete } : {}),
+        ...(fk.onUpdate !== undefined ? { onUpdate: fk.onUpdate } : {}),
+      }),
+    );
+  }
+  return constraints;
+}

package/src/core/migrations/diff-database-schema.ts

@@ -1,13 +1,28 @@
-import type { ColumnDefault, Contract } from '@prisma-next/contract/types';
-import { contractToSchemaIR } from '@prisma-next/family-sql/control';
-import { verifySqlSchemaTree } from '@prisma-next/family-sql/diff';
+import type { ColumnDefault, Contract, ControlPolicy } from '@prisma-next/contract/types';
+import type { NativeTypeExpander, SqlSchemaDiffResult } from '@prisma-next/family-sql/control';
+import { buildNativeTypeExpander, contractToSchemaIR } from '@prisma-next/family-sql/control';
+import {
+  neutralizeFlatExpectedFkSchemas,
+  normalizeFlatActualForDiff,
+  verifySqlSchemaByDiff,
+} from '@prisma-next/family-sql/diff';
 import type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';
-import type { VerifyDatabaseSchemaResult } from '@prisma-next/framework-components/control';
-import { SchemaDiff } from '@prisma-next/framework-components/control';
-import type { SqlStorage, StorageColumn } from '@prisma-next/sql-contract/types';
-import type { SqlSchemaIR, SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';
-import { parseSqliteDefault } from '../default-normalizer';
-import { normalizeSqliteNativeType } from '../native-type-normalizer';
+import type {
+  SchemaDiffIssue,
+  VerifyDatabaseSchemaResult,
+} from '@prisma-next/framework-components/control';
+import { diffSchemas } from '@prisma-next/framework-components/control';
+import { entityAt } from '@prisma-next/framework-components/ir';
+import type { SqlStorage, StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
+import type {
+  SqlColumnIRInput,
+  SqlSchemaIRInput,
+  SqlSchemaIRNode,
+  SqlTableIRInput,
+} from '@prisma-next/sql-schema-ir/types';
+import { relationalNodeGranularity, SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';
+import { blindCast } from '@prisma-next/utils/casts';
+import { ifDefined } from '@prisma-next/utils/defined';
 import { renderDefaultLiteral } from './planner-ddl-builders';
 
 interface SqliteDiffDatabaseSchemaInput {
@@ -29,46 +44,197 @@ export function sqliteRenderDefault(def: ColumnDefault, _column: StorageColumn):
   return renderDefaultLiteral(def.value);
 }
 
-/** The SQLite expected-side projection: contract → flat relational schema IR. */
-export function sqliteContractToSchema(contract: Contract<SqlStorage> | null): SqlSchemaIR {
+/**
+ * The SQLite expected-side projection: contract → flat relational schema IR.
+ *
+ * `extras` thread the plan-time derivation input: the native-type expander,
+ * so the expected side carries resolved native types (like the verify
+ * side). Every expected column also carries its `codecRef` unconditionally
+ * (Decision 5) — the planner's op-builders resolve DDL rendering from it at
+ * plan time, so no separate render stamper is threaded here.
+ */
+export function sqliteContractToSchema(
+  contract: Contract<SqlStorage> | null,
+  extras?: {
+    readonly expandNativeType?: NativeTypeExpander;
+  },
+): SqlSchemaIR {
   return contractToSchemaIR(contract, {
     annotationNamespace: 'sqlite',
     renderDefault: sqliteRenderDefault,
+    ...ifDefined('expandNativeType', extras?.expandNativeType),
   });
 }
 
-function computeSqliteSchemaComparison(
+/**
+ * The SQLite schema verify: the full-tree node-diff verdict wrapped in the
+ * issue-based result envelope. Used by the runner's post-apply check; the
+ * family `verifySchema` runs the same composition via the descriptor hook.
+ */
+export function verifySqliteDatabaseSchema(
   input: SqliteDiffDatabaseSchemaInput,
 ): VerifyDatabaseSchemaResult {
-  return verifySqlSchemaTree({
+  return verifySqlSchemaByDiff({
     contract: input.contract,
-    actualSchema: input.actualSchema,
-    buildExpectedSchema: sqliteContractToSchema,
+    schema: input.actualSchema,
     strict: input.strict,
-    typeMetadataRegistry: input.typeMetadataRegistry,
     frameworkComponents: input.frameworkComponents,
-    normalizeDefault: parseSqliteDefault,
-    normalizeNativeType: normalizeSqliteNativeType,
+    diffSchema: diffSqliteSchema,
+    granularityOf: relationalNodeGranularity,
   });
 }
 
 /**
- * The SQLite `SchemaDiffer` — relational only. SQLite has a single flat
- * schema and no structural (policy) diff, so it runs the shared per-schema
- * relational diff and returns no `schemaDiffIssues`.
+ * Resolves a verdict-diff issue's subject table's declared control policy
+ * directly from the contract. SQLite's expected tree is flat, so the issue
+ * path carries no namespace segment — `path[1]` is the table name (`path[0]`
+ * is the tree root's own id); every contract namespace is searched for that
+ * table name (table names are globally unique in the flat tree — duplicates
+ * across namespaces are rejected earlier, at `contractToSchemaIR`).
  */
-export function diffSqliteDatabaseSchema(input: SqliteDiffDatabaseSchemaInput): SchemaDiff {
-  const relational = computeSqliteSchemaComparison(input);
-  return new SchemaDiff(relational.schema.issues, relational.schema.schemaDiffIssues);
+function resolveControlPolicy(
+  issue: SchemaDiffIssue,
+  contract: Contract<SqlStorage>,
+): ControlPolicy | undefined {
+  const tableName = issue.path[1];
+  if (tableName === undefined) return undefined;
+  for (const namespaceId of Object.keys(contract.storage.namespaces)) {
+    const table = entityAt<StorageTable>(contract.storage, {
+      namespaceId,
+      entityKind: 'table',
+      entityName: tableName,
+    });
+    if (table !== undefined) return table.control;
+  }
+  return undefined;
 }
 
 /**
- * The same comparison as {@link diffSqliteDatabaseSchema}, wrapped in the
- * verify envelope (`ok`/`summary`/`code`/`target`/`timings`) plus the
- * pass/warn/fail tree the CLI renders.
+ * The SQLite full-tree node diff for the family verify verdict: derive the
+ * expected flat tree with resolved leaf values (expander threaded so
+ * parameterized types compare expanded), neutralize the FK schema segment
+ * (single-schema target — introspection stamps none), normalize the actual
+ * tree for semantic satisfaction, and run the generic differ. Flat targets
+ * need no ownership scoping. The codec `verifyType` hooks run once per
+ * contract namespace with tables, each against the sole flat actual root —
+ * exactly the legacy per-namespace pairing.
  */
-export function verifySqliteDatabaseSchema(
-  input: SqliteDiffDatabaseSchemaInput,
-): VerifyDatabaseSchemaResult {
-  return computeSqliteSchemaComparison(input);
+export function diffSqliteSchema(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}): SqlSchemaDiffResult {
+  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);
+  const expected = neutralizeFlatExpectedFkSchemas(
+    contractToSchemaIR(input.contract, {
+      annotationNamespace: 'sqlite',
+      renderDefault: sqliteRenderDefault,
+      ...ifDefined('expandNativeType', expandNativeType),
+    }),
+  );
+  const actual =
+    input.schema instanceof SqlSchemaIR
+      ? input.schema
+      : blindCast<
+          SqlSchemaIR,
+          'the SQLite introspection adapter always produces a flat SqlSchemaIR root'
+        >(input.schema);
+  const normalizedActual = normalizeFlatActualForDiff(expected, actual);
+  const issues = diffSchemas(expected, normalizedActual);
+  const namespacesWithTables = Object.values(input.contract.storage.namespaces).filter(
+    (ns) => Object.keys(ns.entries.table ?? {}).length > 0,
+  );
+  return {
+    issues,
+    resolveControlPolicy: (issue) => resolveControlPolicy(issue, input.contract),
+    namespacePairs: namespacesWithTables.map(() => ({ actual })),
+  };
+}
+
+export interface SqlitePlanDiff {
+  /** The desired ("end") tree — resolved leaf values, incl. `codecRef`, on every column. */
+  readonly expected: SqlSchemaIR;
+  /** The live ("start") tree, normalized for semantic satisfaction against `expected`. */
+  readonly actual: SqlSchemaIR;
+  readonly issues: readonly SchemaDiffIssue[];
+}
+
+/**
+ * The SQLite planner's diff input: the same tree-building
+ * `diffSqliteSchema` uses (expander threaded, FK schema segment
+ * neutralized, actual tree normalized for semantic satisfaction). One differ
+ * drives both verify and plan; this is the plan-side derivation — column DDL
+ * resolves from each expected column's `codecRef` at plan time
+ * (`column-ddl-rendering.ts`), so no separate render stamping happens here.
+ */
+export function buildSqlitePlanDiff(input: {
+  readonly contract: Contract<SqlStorage>;
+  readonly actualSchema: SqlSchemaIRNode;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}): SqlitePlanDiff {
+  const expandNativeType = buildNativeTypeExpander(input.frameworkComponents);
+  const expected = neutralizeFlatExpectedFkSchemas(
+    sqliteContractToSchema(input.contract, {
+      ...ifDefined('expandNativeType', expandNativeType),
+    }),
+  );
+  // The differ dispatches polymorphically (`.isEqualTo()` / `.children()`), so
+  // the actual tree must be genuine `SqlSchemaIR`/`SqlTableIR`/`SqlColumnIR`
+  // instances, not plain data shaped like them. `new SqlSchemaIR(...)`
+  // normalizes either input uniformly (an already-real tree passes through
+  // untouched — its nested values are already instances) and is a no-op
+  // rebuild in the common (real-instance) case, so this is always safe to run.
+  const actualRaw = new SqlSchemaIR(withRecordKeyNames(input.actualSchema));
+  const actual = normalizeFlatActualForDiff(expected, actualRaw);
+  const issues = diffSchemas(expected, actual);
+  return { expected, actual, issues };
+}
+
+/**
+ * Every schema-tree builder in this codebase derives a table's / column's
+ * `name` from the record key it's stored under (`contractToSchemaIR`,
+ * the SQLite introspection adapter) rather than trusting a redundant
+ * embedded field — the record key IS the identity. Mirrors that discipline
+ * for the actual/live tree before construction, so `SqlTableIR.id` /
+ * `SqlColumnIR.id` (both derived from `.name`) are always correct without
+ * requiring every caller to duplicate the key onto the value. A no-op for a
+ * tree that already carries matching names (the real introspection adapter
+ * always does).
+ */
+function withRecordKeyNames(actualSchema: SqlSchemaIRNode): SqlSchemaIRInput {
+  const raw = blindCast<
+    { readonly tables?: Readonly<Record<string, unknown>> },
+    'the SQLite introspection adapter always produces a flat, tables-keyed root'
+  >(actualSchema);
+  const tables: Record<string, SqlTableIRInput> = {};
+  for (const [tableName, table] of Object.entries(raw.tables ?? {})) {
+    const rawTable = blindCast<
+      Omit<SqlTableIRInput, 'name' | 'columns'>,
+      'every table value in a tables record is SqlTableIR(Input)-shaped'
+    >(table);
+    const columns: Record<string, SqlColumnIRInput> = {};
+    for (const [columnName, column] of Object.entries(
+      blindCast<
+        { readonly columns?: Readonly<Record<string, unknown>> },
+        'every SqlTableIR(Input) carries a columns record keyed by column name'
+      >(table).columns ?? {},
+    )) {
+      columns[columnName] = {
+        ...blindCast<
+          SqlColumnIRInput,
+          'every column value in a columns record is SqlColumnIR(Input)-shaped'
+        >(column),
+        name: columnName,
+      };
+    }
+    tables[tableName] = {
+      ...rawTable,
+      name: tableName,
+      columns,
+      foreignKeys: rawTable.foreignKeys ?? [],
+      uniques: rawTable.uniques ?? [],
+      indexes: rawTable.indexes ?? [],
+    };
+  }
+  return { tables };
 }