@prisma-next/target-postgres 0.3.0-pr.99.6 → 0.4.0-dev.2

package/src/core/migrations/planner-ddl-builders.ts

@@ -0,0 +1,256 @@
+import { escapeLiteral, quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import type { CodecControlHooks } from '@prisma-next/family-sql/control';
+import type {
+  ForeignKey,
+  ReferentialAction,
+  StorageColumn,
+  StorageTable,
+  StorageTypeInstance,
+} from '@prisma-next/sql-contract/types';
+import type { PostgresColumnDefault } from '../types';
+import { qualifyTableName } from './planner-sql-checks';
+import { resolveColumnTypeMetadata } from './planner-type-resolution';
+
+export function buildCreateTableSql(
+  qualifiedTableName: string,
+  table: StorageTable,
+  codecHooks: Map<string, CodecControlHooks>,
+  storageTypes: Record<string, StorageTypeInstance> = {},
+): string {
+  const columnDefinitions = Object.entries(table.columns).map(
+    ([columnName, column]: [string, StorageColumn]) => {
+      const parts = [
+        quoteIdentifier(columnName),
+        buildColumnTypeSql(column, codecHooks, storageTypes),
+        buildColumnDefaultSql(column.default, column),
+        column.nullable ? '' : 'NOT NULL',
+      ].filter(Boolean);
+      return parts.join(' ');
+    },
+  );
+
+  const constraintDefinitions: string[] = [];
+  if (table.primaryKey) {
+    constraintDefinitions.push(
+      `PRIMARY KEY (${table.primaryKey.columns.map(quoteIdentifier).join(', ')})`,
+    );
+  }
+
+  const allDefinitions = [...columnDefinitions, ...constraintDefinitions];
+  return `CREATE TABLE ${qualifiedTableName} (\n  ${allDefinitions.join(',\n  ')}\n)`;
+}
+
+/**
+ * Pattern for safe PostgreSQL type names.
+ * Allows letters, digits, underscores, spaces (for "double precision", "character varying"),
+ * and trailing [] for array types.
+ */
+const SAFE_NATIVE_TYPE_PATTERN = /^[a-zA-Z][a-zA-Z0-9_ ]*(\[\])?$/;
+
+function assertSafeNativeType(nativeType: string): void {
+  if (!SAFE_NATIVE_TYPE_PATTERN.test(nativeType)) {
+    throw new Error(
+      `Unsafe native type name in contract: "${nativeType}". ` +
+        'Native type names must match /^[a-zA-Z][a-zA-Z0-9_ ]*(\\[\\])?$/',
+    );
+  }
+}
+
+/**
+ * Sanity check against accidental SQL injection from malformed contract files.
+ * Rejects semicolons, SQL comment tokens, and dollar-quoting.
+ * Not a comprehensive security boundary — the contract is developer-authored.
+ */
+function assertSafeDefaultExpression(expression: string): void {
+  if (expression.includes(';') || /--|\/\*|\$\$|\bSELECT\b/i.test(expression)) {
+    throw new Error(
+      `Unsafe default expression in contract: "${expression}". ` +
+        'Default expressions must not contain semicolons, SQL comment tokens, dollar-quoting, or subqueries.',
+    );
+  }
+}
+
+/**
+ * Renders the SQL type for a column in DDL context.
+ *
+ * @param allowPseudoTypes - When true (default), autoincrement integer columns
+ *   produce SERIAL/BIGSERIAL/SMALLSERIAL pseudo-types. Set to false for contexts
+ *   like ALTER COLUMN TYPE where pseudo-types are invalid.
+ */
+export function buildColumnTypeSql(
+  column: StorageColumn,
+  codecHooks: Map<string, CodecControlHooks>,
+  storageTypes: Record<string, StorageTypeInstance> = {},
+  allowPseudoTypes = true,
+): string {
+  const resolved = resolveColumnTypeMetadata(column, storageTypes);
+
+  if (allowPseudoTypes) {
+    const columnDefault = column.default;
+    if (columnDefault?.kind === 'function' && columnDefault.expression === 'autoincrement()') {
+      if (resolved.nativeType === 'int4' || resolved.nativeType === 'integer') {
+        return 'SERIAL';
+      }
+      if (resolved.nativeType === 'int8' || resolved.nativeType === 'bigint') {
+        return 'BIGSERIAL';
+      }
+      if (resolved.nativeType === 'int2' || resolved.nativeType === 'smallint') {
+        return 'SMALLSERIAL';
+      }
+    }
+  }
+
+  const expanded = expandParameterizedTypeSql(resolved, codecHooks);
+  if (expanded !== null) {
+    return expanded;
+  }
+
+  if (column.typeRef) {
+    return quoteIdentifier(resolved.nativeType);
+  }
+
+  assertSafeNativeType(resolved.nativeType);
+  return resolved.nativeType;
+}
+
+function expandParameterizedTypeSql(
+  column: Pick<StorageColumn, 'nativeType' | 'codecId' | 'typeParams'>,
+  codecHooks: Map<string, CodecControlHooks>,
+): string | null {
+  if (!column.typeParams) {
+    return null;
+  }
+
+  if (!column.codecId) {
+    throw new Error(
+      `Column declares typeParams for nativeType "${column.nativeType}" but has no codecId. ` +
+        'Ensure the column is associated with a codec.',
+    );
+  }
+
+  const hooks = codecHooks.get(column.codecId);
+  if (!hooks?.expandNativeType) {
+    if (hooks?.planTypeOperations) {
+      return null;
+    }
+    throw new Error(
+      `Column declares typeParams for nativeType "${column.nativeType}" ` +
+        `but no expandNativeType hook is registered for codecId "${column.codecId}". ` +
+        'Ensure the extension providing this codec is included in extensionPacks.',
+    );
+  }
+
+  const expanded = hooks.expandNativeType({
+    nativeType: column.nativeType,
+    codecId: column.codecId,
+    typeParams: column.typeParams,
+  });
+
+  return expanded !== column.nativeType ? expanded : null;
+}
+
+/** Autoincrement columns use SERIAL types, so this returns empty for them. */
+export function buildColumnDefaultSql(
+  columnDefault: PostgresColumnDefault | undefined,
+  column?: StorageColumn,
+): string {
+  if (!columnDefault) {
+    return '';
+  }
+
+  switch (columnDefault.kind) {
+    case 'literal':
+      return `DEFAULT ${renderDefaultLiteral(columnDefault.value, column)}`;
+    case 'function': {
+      if (columnDefault.expression === 'autoincrement()') {
+        return '';
+      }
+      assertSafeDefaultExpression(columnDefault.expression);
+      return `DEFAULT (${columnDefault.expression})`;
+    }
+    case 'sequence':
+      return `DEFAULT nextval('${escapeLiteral(quoteIdentifier(columnDefault.name))}'::regclass)`;
+  }
+}
+
+export function renderDefaultLiteral(value: unknown, column?: StorageColumn): string {
+  const isJsonColumn = column?.nativeType === 'json' || column?.nativeType === 'jsonb';
+
+  if (value instanceof Date) {
+    return `'${escapeLiteral(value.toISOString())}'`;
+  }
+  if (typeof value === 'string') {
+    return `'${escapeLiteral(value)}'`;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (value === null) {
+    return 'NULL';
+  }
+  const json = JSON.stringify(value);
+  if (isJsonColumn) {
+    return `'${escapeLiteral(json)}'::${column.nativeType}`;
+  }
+  return `'${escapeLiteral(json)}'`;
+}
+
+export function buildAddColumnSql(
+  qualifiedTableName: string,
+  columnName: string,
+  column: StorageColumn,
+  codecHooks: Map<string, CodecControlHooks>,
+  temporaryDefault?: string | null,
+  storageTypes: Record<string, StorageTypeInstance> = {},
+): string {
+  const typeSql = buildColumnTypeSql(column, codecHooks, storageTypes);
+  const defaultSql =
+    buildColumnDefaultSql(column.default, column) ||
+    (temporaryDefault ? `DEFAULT ${temporaryDefault}` : '');
+  const parts = [
+    `ALTER TABLE ${qualifiedTableName}`,
+    `ADD COLUMN ${quoteIdentifier(columnName)} ${typeSql}`,
+    defaultSql,
+    column.nullable ? '' : 'NOT NULL',
+  ].filter(Boolean);
+  return parts.join(' ');
+}
+
+const REFERENTIAL_ACTION_SQL: Record<ReferentialAction, string> = {
+  noAction: 'NO ACTION',
+  restrict: 'RESTRICT',
+  cascade: 'CASCADE',
+  setNull: 'SET NULL',
+  setDefault: 'SET DEFAULT',
+};
+
+export function buildForeignKeySql(
+  schemaName: string,
+  tableName: string,
+  fkName: string,
+  foreignKey: ForeignKey,
+): string {
+  let sql = `ALTER TABLE ${qualifyTableName(schemaName, tableName)}
+ADD CONSTRAINT ${quoteIdentifier(fkName)}
+FOREIGN KEY (${foreignKey.columns.map(quoteIdentifier).join(', ')})
+REFERENCES ${qualifyTableName(schemaName, foreignKey.references.table)} (${foreignKey.references.columns
+    .map(quoteIdentifier)
+    .join(', ')})`;
+
+  if (foreignKey.onDelete !== undefined) {
+    const action = REFERENTIAL_ACTION_SQL[foreignKey.onDelete];
+    if (!action) {
+      throw new Error(`Unknown referential action for onDelete: ${String(foreignKey.onDelete)}`);
+    }
+    sql += `\nON DELETE ${action}`;
+  }
+  if (foreignKey.onUpdate !== undefined) {
+    const action = REFERENTIAL_ACTION_SQL[foreignKey.onUpdate];
+    if (!action) {
+      throw new Error(`Unknown referential action for onUpdate: ${String(foreignKey.onUpdate)}`);
+    }
+    sql += `\nON UPDATE ${action}`;
+  }
+
+  return sql;
+}

package/src/core/migrations/planner-identity-values.ts

@@ -0,0 +1,135 @@
+import type { CodecControlHooks } from '@prisma-next/family-sql/control';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import { ifDefined } from '@prisma-next/utils/defined';
+
+/**
+ * Resolves the identity value (monoid neutral element) as a SQL literal for a column's type.
+ * Checks codec hooks first (extensions can provide type-specific identity values),
+ * then falls back to the built-in map.
+ */
+export function resolveIdentityValue(
+  column: StorageColumn,
+  codecHooks: Map<string, CodecControlHooks>,
+  storageTypes: Record<string, StorageTypeInstance> = {},
+): string | null {
+  const referencedType = column.typeRef ? storageTypes[column.typeRef] : undefined;
+  const codecId = referencedType?.codecId ?? column.codecId;
+  const nativeType = referencedType?.nativeType ?? column.nativeType;
+  const typeParams = referencedType?.typeParams ?? column.typeParams;
+
+  if (codecId) {
+    const hookDefault = codecHooks.get(codecId)?.resolveIdentityValue?.({
+      nativeType,
+      codecId,
+      ...ifDefined('typeParams', typeParams),
+    });
+    if (hookDefault !== undefined) {
+      return hookDefault;
+    }
+  }
+
+  return buildBuiltinIdentityValue(nativeType, typeParams);
+}
+
+/**
+ * Returns the built-in identity value (monoid neutral element) as a SQL literal for the given
+ * PostgreSQL native type — e.g. 0 for integers, '' for text, false for booleans.
+ *
+ * This is the planner's fallback when no codec hook provides a type-specific identity value.
+ *
+ * Returns null for unrecognized types (for example enums and extension-owned types without a
+ * hook), which causes the planner to fall back to the empty-table precheck.
+ *
+ * @internal Exported for testing only.
+ */
+export function buildBuiltinIdentityValue(
+  nativeType: string,
+  typeParams?: Record<string, unknown>,
+): string | null {
+  const normalizedNativeType = normalizeIdentityValueNativeType(nativeType);
+
+  if (normalizedNativeType.endsWith('[]')) {
+    return "'{}'";
+  }
+
+  switch (normalizedNativeType) {
+    case 'text':
+    case 'character':
+    case 'bpchar':
+    case 'character varying':
+    case 'varchar':
+      return "''";
+
+    case 'int2':
+    case 'int4':
+    case 'int8':
+    case 'integer':
+    case 'bigint':
+    case 'smallint':
+    case 'float4':
+    case 'float8':
+    case 'real':
+    case 'double precision':
+    case 'numeric':
+    case 'decimal':
+      return '0';
+
+    case 'bool':
+    case 'boolean':
+      return 'false';
+
+    case 'uuid':
+      return "'00000000-0000-0000-0000-000000000000'";
+
+    case 'json':
+      return "'{}'::json";
+    case 'jsonb':
+      return "'{}'::jsonb";
+
+    case 'date':
+    case 'timestamp':
+    case 'timestamptz':
+    case 'timestamp with time zone':
+    case 'timestamp without time zone':
+      return "'epoch'";
+
+    case 'time':
+    case 'time without time zone':
+      return "'00:00:00'";
+    case 'timetz':
+    case 'time with time zone':
+      return "'00:00:00+00'";
+
+    case 'interval':
+      return "'0'";
+
+    case 'bytea':
+      return "''::bytea";
+    case 'tsvector':
+      return "''::tsvector";
+
+    case 'bit':
+      return buildBitIdentityValue(typeParams);
+    case 'bit varying':
+    case 'varbit':
+      return "B''";
+
+    default:
+      return null;
+  }
+}
+
+function normalizeIdentityValueNativeType(nativeType: string): string {
+  return nativeType.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+
+function buildBitIdentityValue(typeParams?: Record<string, unknown>): string | null {
+  const length = typeParams?.['length'];
+  if (length === undefined) {
+    return "B'0'";
+  }
+  if (typeof length !== 'number' || !Number.isInteger(length) || length <= 0) {
+    return null;
+  }
+  return `B'${'0'.repeat(length)}'`;
+}

package/src/core/migrations/planner-recipes.ts

@@ -0,0 +1,91 @@
+import { quoteIdentifier } from '@prisma-next/adapter-postgres/control';
+import type { CodecControlHooks, SqlMigrationPlanOperation } from '@prisma-next/family-sql/control';
+import type { StorageColumn, StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import { buildAddColumnSql } from './planner-ddl-builders';
+import {
+  columnExistsCheck,
+  columnHasNoDefaultCheck,
+  columnNullabilityCheck,
+  qualifyTableName,
+} from './planner-sql-checks';
+import { buildTargetDetails, type PostgresPlanTargetDetails } from './planner-target-details';
+
+export function buildAddColumnOperationIdentity(
+  schema: string,
+  tableName: string,
+  columnName: string,
+): Pick<
+  SqlMigrationPlanOperation<PostgresPlanTargetDetails>,
+  'id' | 'label' | 'summary' | 'target'
+> {
+  return {
+    id: `column.${tableName}.${columnName}`,
+    label: `Add column ${columnName} to ${tableName}`,
+    summary: `Adds column ${columnName} to table ${tableName}`,
+    target: {
+      id: 'postgres',
+      details: buildTargetDetails('table', tableName, schema),
+    },
+  };
+}
+
+export function buildAddNotNullColumnWithTemporaryDefaultOperation(options: {
+  readonly schema: string;
+  readonly tableName: string;
+  readonly columnName: string;
+  readonly column: StorageColumn;
+  readonly codecHooks: Map<string, CodecControlHooks>;
+  readonly storageTypes: Record<string, StorageTypeInstance>;
+  readonly temporaryDefault: string;
+}): SqlMigrationPlanOperation<PostgresPlanTargetDetails> {
+  const { schema, tableName, columnName, column, codecHooks, storageTypes, temporaryDefault } =
+    options;
+  const qualified = qualifyTableName(schema, tableName);
+
+  return {
+    ...buildAddColumnOperationIdentity(schema, tableName, columnName),
+    operationClass: 'additive',
+    precheck: [
+      {
+        description: `ensure column "${columnName}" is missing`,
+        sql: columnExistsCheck({ schema, table: tableName, column: columnName, exists: false }),
+      },
+    ],
+    execute: [
+      {
+        description: `add column "${columnName}"`,
+        sql: buildAddColumnSql(
+          qualified,
+          columnName,
+          column,
+          codecHooks,
+          temporaryDefault,
+          storageTypes,
+        ),
+      },
+      {
+        description: `drop temporary default from column "${columnName}"`,
+        sql: `ALTER TABLE ${qualified} ALTER COLUMN ${quoteIdentifier(columnName)} DROP DEFAULT`,
+      },
+    ],
+    postcheck: [
+      {
+        description: `verify column "${columnName}" exists`,
+        sql: columnExistsCheck({ schema, table: tableName, column: columnName }),
+      },
+      {
+        description: `verify column "${columnName}" is NOT NULL`,
+        sql: columnNullabilityCheck({
+          schema,
+          table: tableName,
+          column: columnName,
+          nullable: false,
+        }),
+      },
+      {
+        description: `verify column "${columnName}" has no default after temporary default removal`,
+        sql: columnHasNoDefaultCheck({ schema, table: tableName, column: columnName }),
+      },
+    ],
+  };
+}