@prisma-next/adapter-postgres 0.3.0-dev.10 → 0.3.0-dev.113

package/src/core/control-mutation-defaults.ts

@@ -0,0 +1,335 @@
+import type { ExecutionMutationDefaultValue } from '@prisma-next/contract/types';
+import type {
+  ControlMutationDefaultFunctionEntry,
+  ControlMutationDefaultGeneratorDescriptor,
+  PslScalarTypeDescriptor,
+} from '@prisma-next/family-sql/control';
+import {
+  builtinGeneratorRegistryMetadata,
+  resolveBuiltinGeneratedColumnDescriptor,
+} from '@prisma-next/ids';
+import type {
+  DefaultFunctionLoweringContext,
+  DefaultFunctionLoweringHandler,
+} from '@prisma-next/sql-contract-psl';
+
+type LoweredDefaultResult = ReturnType<DefaultFunctionLoweringHandler>;
+type ParsedDefaultFunctionCall = Parameters<DefaultFunctionLoweringHandler>[0]['call'];
+
+function invalidArgumentDiagnostic(input: {
+  readonly context: DefaultFunctionLoweringContext;
+  readonly span: ParsedDefaultFunctionCall['span'];
+  readonly message: string;
+}): LoweredDefaultResult {
+  return {
+    ok: false,
+    diagnostic: {
+      code: 'PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT',
+      message: input.message,
+      sourceId: input.context.sourceId,
+      span: input.span,
+    },
+  };
+}
+
+function executionGenerator(
+  id: ExecutionMutationDefaultValue['id'],
+  params?: Record<string, unknown>,
+): LoweredDefaultResult {
+  return {
+    ok: true,
+    value: {
+      kind: 'execution',
+      generated: {
+        kind: 'generator',
+        id,
+        ...(params ? { params } : {}),
+      },
+    },
+  };
+}
+
+function expectNoArgs(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+  readonly usage: string;
+}): LoweredDefaultResult | undefined {
+  if (input.call.args.length === 0) {
+    return undefined;
+  }
+  return invalidArgumentDiagnostic({
+    context: input.context,
+    span: input.call.span,
+    message: `Default function "${input.call.name}" does not accept arguments. Use ${input.usage}.`,
+  });
+}
+
+function parseIntegerArgument(raw: string): number | undefined {
+  const trimmed = raw.trim();
+  if (!/^-?\d+$/.test(trimmed)) {
+    return undefined;
+  }
+  const value = Number(trimmed);
+  if (!Number.isInteger(value)) {
+    return undefined;
+  }
+  return value;
+}
+
+function parseStringLiteral(raw: string): string | undefined {
+  const match = raw.trim().match(/^(['"])(.*)\1$/s);
+  if (!match) {
+    return undefined;
+  }
+  return match[2] ?? '';
+}
+
+function lowerAutoincrement(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  const maybeNoArgs = expectNoArgs({
+    call: input.call,
+    context: input.context,
+    usage: '`autoincrement()`',
+  });
+  if (maybeNoArgs) {
+    return maybeNoArgs;
+  }
+  return {
+    ok: true,
+    value: {
+      kind: 'storage',
+      defaultValue: {
+        kind: 'function',
+        expression: 'autoincrement()',
+      },
+    },
+  };
+}
+
+function lowerNow(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  const maybeNoArgs = expectNoArgs({
+    call: input.call,
+    context: input.context,
+    usage: '`now()`',
+  });
+  if (maybeNoArgs) {
+    return maybeNoArgs;
+  }
+  return {
+    ok: true,
+    value: {
+      kind: 'storage',
+      defaultValue: {
+        kind: 'function',
+        expression: 'now()',
+      },
+    },
+  };
+}
+
+function lowerUuid(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  if (input.call.args.length === 0) {
+    return executionGenerator('uuidv4');
+  }
+  if (input.call.args.length !== 1) {
+    return invalidArgumentDiagnostic({
+      context: input.context,
+      span: input.call.span,
+      message:
+        'Default function "uuid" accepts at most one version argument: `uuid()`, `uuid(4)`, or `uuid(7)`.',
+    });
+  }
+  const version = parseIntegerArgument(input.call.args[0]?.raw ?? '');
+  if (version === 4) {
+    return executionGenerator('uuidv4');
+  }
+  if (version === 7) {
+    return executionGenerator('uuidv7');
+  }
+  return invalidArgumentDiagnostic({
+    context: input.context,
+    span: input.call.args[0]?.span ?? input.call.span,
+    message:
+      'Default function "uuid" supports only `uuid()`, `uuid(4)`, or `uuid(7)` in SQL PSL provider v1.',
+  });
+}
+
+function lowerCuid(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  if (input.call.args.length === 0) {
+    return {
+      ok: false,
+      diagnostic: {
+        code: 'PSL_UNKNOWN_DEFAULT_FUNCTION',
+        message:
+          'Default function "cuid()" is not supported in SQL PSL provider v1. Use `cuid(2)` instead.',
+        sourceId: input.context.sourceId,
+        span: input.call.span,
+      },
+    };
+  }
+  if (input.call.args.length !== 1) {
+    return invalidArgumentDiagnostic({
+      context: input.context,
+      span: input.call.span,
+      message: 'Default function "cuid" accepts exactly one version argument: `cuid(2)`.',
+    });
+  }
+  const version = parseIntegerArgument(input.call.args[0]?.raw ?? '');
+  if (version === 2) {
+    return executionGenerator('cuid2');
+  }
+  return invalidArgumentDiagnostic({
+    context: input.context,
+    span: input.call.args[0]?.span ?? input.call.span,
+    message: 'Default function "cuid" supports only `cuid(2)` in SQL PSL provider v1.',
+  });
+}
+
+function lowerUlid(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  const maybeNoArgs = expectNoArgs({
+    call: input.call,
+    context: input.context,
+    usage: '`ulid()`',
+  });
+  if (maybeNoArgs) {
+    return maybeNoArgs;
+  }
+  return executionGenerator('ulid');
+}
+
+function lowerNanoid(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  if (input.call.args.length === 0) {
+    return executionGenerator('nanoid');
+  }
+  if (input.call.args.length !== 1) {
+    return invalidArgumentDiagnostic({
+      context: input.context,
+      span: input.call.span,
+      message:
+        'Default function "nanoid" accepts at most one size argument: `nanoid()` or `nanoid(<2-255>)`.',
+    });
+  }
+  const size = parseIntegerArgument(input.call.args[0]?.raw ?? '');
+  if (size !== undefined && size >= 2 && size <= 255) {
+    return executionGenerator('nanoid', { size });
+  }
+  return invalidArgumentDiagnostic({
+    context: input.context,
+    span: input.call.args[0]?.span ?? input.call.span,
+    message: 'Default function "nanoid" size argument must be an integer between 2 and 255.',
+  });
+}
+
+function lowerDbgenerated(input: {
+  readonly call: ParsedDefaultFunctionCall;
+  readonly context: DefaultFunctionLoweringContext;
+}): LoweredDefaultResult {
+  if (input.call.args.length !== 1) {
+    return invalidArgumentDiagnostic({
+      context: input.context,
+      span: input.call.span,
+      message:
+        'Default function "dbgenerated" requires exactly one string argument: `dbgenerated("...")`.',
+    });
+  }
+  const rawExpression = parseStringLiteral(input.call.args[0]?.raw ?? '');
+  if (rawExpression === undefined) {
+    return invalidArgumentDiagnostic({
+      context: input.context,
+      span: input.call.args[0]?.span ?? input.call.span,
+      message: 'Default function "dbgenerated" argument must be a string literal.',
+    });
+  }
+  if (rawExpression.trim().length === 0) {
+    return invalidArgumentDiagnostic({
+      context: input.context,
+      span: input.call.args[0]?.span ?? input.call.span,
+      message: 'Default function "dbgenerated" argument cannot be empty.',
+    });
+  }
+  return {
+    ok: true,
+    value: {
+      kind: 'storage',
+      defaultValue: {
+        kind: 'function',
+        expression: rawExpression,
+      },
+    },
+  };
+}
+
+const postgresDefaultFunctionRegistryEntries = [
+  ['autoincrement', { lower: lowerAutoincrement, usageSignatures: ['autoincrement()'] }],
+  ['now', { lower: lowerNow, usageSignatures: ['now()'] }],
+  ['uuid', { lower: lowerUuid, usageSignatures: ['uuid()', 'uuid(4)', 'uuid(7)'] }],
+  ['cuid', { lower: lowerCuid, usageSignatures: ['cuid(2)'] }],
+  ['ulid', { lower: lowerUlid, usageSignatures: ['ulid()'] }],
+  ['nanoid', { lower: lowerNanoid, usageSignatures: ['nanoid()', 'nanoid(<2-255>)'] }],
+  ['dbgenerated', { lower: lowerDbgenerated, usageSignatures: ['dbgenerated("...")'] }],
+] satisfies ReadonlyArray<readonly [string, ControlMutationDefaultFunctionEntry]>;
+
+const postgresPslScalarTypeDescriptors = new Map<string, PslScalarTypeDescriptor>([
+  ['String', { codecId: 'pg/text@1', nativeType: 'text' }],
+  ['Boolean', { codecId: 'pg/bool@1', nativeType: 'bool' }],
+  ['Int', { codecId: 'pg/int4@1', nativeType: 'int4' }],
+  ['BigInt', { codecId: 'pg/int8@1', nativeType: 'int8' }],
+  ['Float', { codecId: 'pg/float8@1', nativeType: 'float8' }],
+  ['Decimal', { codecId: 'pg/numeric@1', nativeType: 'numeric' }],
+  ['DateTime', { codecId: 'pg/timestamptz@1', nativeType: 'timestamptz' }],
+  ['Json', { codecId: 'pg/jsonb@1', nativeType: 'jsonb' }],
+  ['Bytes', { codecId: 'pg/bytea@1', nativeType: 'bytea' }],
+]);
+
+export function createPostgresDefaultFunctionRegistry(): ReadonlyMap<
+  string,
+  ControlMutationDefaultFunctionEntry
+> {
+  return new Map(postgresDefaultFunctionRegistryEntries);
+}
+
+export function createPostgresMutationDefaultGeneratorDescriptors(): readonly ControlMutationDefaultGeneratorDescriptor[] {
+  return builtinGeneratorRegistryMetadata.map(({ id, applicableCodecIds }) => ({
+    id,
+    applicableCodecIds,
+    resolveGeneratedColumnDescriptor: ({ generated }) => {
+      if (generated.kind !== 'generator' || generated.id !== id) {
+        return undefined;
+      }
+      const descriptor = resolveBuiltinGeneratedColumnDescriptor({
+        id,
+        ...(generated.params ? { params: generated.params } : {}),
+      });
+      return {
+        codecId: descriptor.type.codecId,
+        nativeType: descriptor.type.nativeType,
+        ...(descriptor.type.typeRef ? { typeRef: descriptor.type.typeRef } : {}),
+        ...(descriptor.typeParams ? { typeParams: descriptor.typeParams } : {}),
+      };
+    },
+  }));
+}
+
+export function createPostgresPslScalarTypeDescriptors(): ReadonlyMap<
+  string,
+  PslScalarTypeDescriptor
+> {
+  return new Map(postgresPslScalarTypeDescriptors);
+}

package/src/core/default-normalizer.ts

@@ -0,0 +1,138 @@
+import type { ColumnDefault } from '@prisma-next/contract/types';
+
+/**
+ * Pre-compiled regex patterns for performance.
+ * These are compiled once at module load time rather than on each function call.
+ */
+const NEXTVAL_PATTERN = /^nextval\s*\(/i;
+const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
+const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
+const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
+const TEXT_CAST_SUFFIX = /::text$/i;
+const NOW_LITERAL_PATTERN = /^'now'$/i;
+const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
+const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
+const NULL_PATTERN = /^NULL(?:::.+)?$/i;
+const TRUE_PATTERN = /^true$/i;
+const FALSE_PATTERN = /^false$/i;
+const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
+const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
+
+/**
+ * Returns the canonical expression for a timestamp default function, or undefined
+ * if the expression is not a recognized timestamp default.
+ *
+ * Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:
+ * - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'
+ * - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'
+ *
+ * These are semantically different in Postgres: now() returns the transaction
+ * start time (constant within a transaction), while clock_timestamp() returns
+ * the actual wall-clock time (can differ across rows in a single INSERT).
+ */
+function canonicalizeTimestampDefault(expr: string): string | undefined {
+  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';
+  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';
+
+  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;
+
+  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();
+
+  // Strip outer parentheses
+  if (inner.startsWith('(') && inner.endsWith(')')) {
+    inner = inner.slice(1, -1).trim();
+  }
+
+  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';
+  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';
+
+  // Handle 'now'::text form (Postgres casts the string literal 'now' through ::text)
+  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();
+  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';
+
+  return undefined;
+}
+
+/**
+ * Parses a raw Postgres column default expression into a normalized ColumnDefault.
+ * This enables semantic comparison between contract defaults and introspected schema defaults.
+ *
+ * Used by the migration diff layer to normalize raw database defaults during comparison,
+ * keeping the introspection layer focused on faithful data capture.
+ *
+ * @param rawDefault - Raw default expression from information_schema.columns.column_default
+ * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)
+ * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed
+ */
+export function parsePostgresDefault(
+  rawDefault: string,
+  nativeType?: string,
+): ColumnDefault | undefined {
+  const trimmed = rawDefault.trim();
+  const normalizedType = nativeType?.toLowerCase();
+  const isBigInt = normalizedType === 'bigint' || normalizedType === 'int8';
+
+  // Autoincrement: nextval('tablename_column_seq'::regclass)
+  if (NEXTVAL_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'autoincrement()' };
+  }
+
+  // Timestamp defaults: now()/CURRENT_TIMESTAMP → 'now()', clock_timestamp() → 'clock_timestamp()'
+  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
+  if (canonicalTimestamp) {
+    return { kind: 'function', expression: canonicalTimestamp };
+  }
+
+  // gen_random_uuid()
+  if (UUID_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'gen_random_uuid()' };
+  }
+
+  // uuid_generate_v4() from uuid-ossp extension
+  if (UUID_OSSP_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'gen_random_uuid()' };
+  }
+
+  // NULL or NULL::type — explicit null default
+  if (NULL_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: null };
+  }
+
+  // Boolean literals
+  if (TRUE_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: true };
+  }
+  if (FALSE_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: false };
+  }
+
+  // Numeric literals (integer or decimal)
+  if (NUMERIC_PATTERN.test(trimmed)) {
+    if (isBigInt) {
+      return { kind: 'literal', value: { $type: 'bigint', value: trimmed } };
+    }
+    const num = Number(trimmed);
+    if (!Number.isFinite(num)) return undefined;
+    return { kind: 'literal', value: num };
+  }
+
+  // String literals: 'value'::type or just 'value'
+  // Match: 'some text'::text, 'hello'::character varying, 'value', etc.
+  // Strip the ::type cast so the normalized expression matches what contract authors write.
+  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
+  if (stringMatch?.[1] !== undefined) {
+    const unescaped = stringMatch[1].replace(/''/g, "'");
+    if (normalizedType === 'json' || normalizedType === 'jsonb') {
+      try {
+        return { kind: 'literal', value: JSON.parse(unescaped) };
+      } catch {
+        // Keep legacy behavior for malformed/non-JSON string content.
+      }
+    }
+    return { kind: 'literal', value: unescaped };
+  }
+
+  // Unrecognized expression - return as a function with the raw expression
+  // This preserves the information for debugging while still being comparable
+  return { kind: 'function', expression: trimmed };
+}