@prisma-next/target-postgres 0.4.0-dev.9 → 0.4.2

package/src/core/default-normalizer.ts

@@ -0,0 +1,131 @@
+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();
+
+  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()';
+
+  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';
+
+  if (NEXTVAL_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'autoincrement()' };
+  }
+
+  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
+  if (canonicalTimestamp) {
+    return { kind: 'function', expression: canonicalTimestamp };
+  }
+
+  if (UUID_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'gen_random_uuid()' };
+  }
+
+  if (UUID_OSSP_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'gen_random_uuid()' };
+  }
+
+  if (NULL_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: null };
+  }
+
+  if (TRUE_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: true };
+  }
+  if (FALSE_PATTERN.test(trimmed)) {
+    return { kind: 'literal', value: false };
+  }
+
+  if (NUMERIC_PATTERN.test(trimmed)) {
+    const num = Number(trimmed);
+    if (!Number.isFinite(num)) return undefined;
+    if (isBigInt && !Number.isSafeInteger(num)) {
+      return { kind: 'literal', value: trimmed };
+    }
+    return { kind: 'literal', value: num };
+  }
+
+  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.
+      }
+    }
+    if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {
+      const num = Number(unescaped);
+      if (Number.isSafeInteger(num)) {
+        return { kind: 'literal', value: num };
+      }
+      return { kind: 'literal', value: unescaped };
+    }
+    return { kind: 'literal', value: unescaped };
+  }
+
+  return { kind: 'function', expression: trimmed };
+}

package/src/core/descriptor-meta.ts

@@ -1,5 +1,5 @@
-import type { CodecTypes } from '@prisma-next/adapter-postgres/codec-types';
 import { postgresAuthoringFieldPresets, postgresAuthoringTypes } from './authoring';
+import type { CodecTypes } from './codecs';
 
 const postgresTargetDescriptorMetaBase = {
   kind: 'target',

package/src/core/errors.ts

@@ -0,0 +1,33 @@
+import { CliStructuredError } from '@prisma-next/errors/control';
+
+/**
+ * A `PostgresMigration` instance method that needs the materialized control
+ * adapter (currently only `this.dataTransform(...)`) was invoked, but the
+ * migration was constructed without a `ControlStack`. Concrete authoring
+ * usage always goes through the migration CLI entrypoint, which assembles
+ * a stack from the loaded `prisma-next.config.ts`; reaching this error
+ * means a test fixture or ad-hoc consumer instantiated `PostgresMigration`
+ * with the no-arg form (legal for `operations` / `describe` introspection
+ * only).
+ *
+ * Distinct from `PN-MIG-2001` (placeholder not filled) and `PN-MIG-2005`
+ * (data-transform query plan against wrong contract) because the missing
+ * input is the stack itself, not the per-operation contract.
+ *
+ * Lives in `@prisma-next/target-postgres/errors` rather than the shared
+ * framework migration errors module because the failure is target-specific:
+ * the contract it talks about (`PostgresMigration`, the Postgres control
+ * adapter, the Postgres-target stack) only exists in this package.
+ */
+export function errorPostgresMigrationStackMissing(): CliStructuredError {
+  return new CliStructuredError(
+    '2007',
+    'PostgresMigration.dataTransform requires a control adapter',
+    {
+      domain: 'MIG',
+      why: 'PostgresMigration.dataTransform was invoked on an instance constructed without a ControlStack. The stored controlAdapter is undefined, so dataTransform cannot lower its query plan.',
+      fix: 'Construct the migration via the migration CLI entrypoint (which assembles a ControlStack from the loaded prisma-next.config.ts), or pass a ControlStack containing a Postgres adapter to the migration constructor in test fixtures.',
+      meta: {},
+    },
+  );
+}

package/src/core/json-schema-type-expression.ts

@@ -0,0 +1,131 @@
+type JsonSchemaRecord = Record<string, unknown>;
+
+const MAX_DEPTH = 32;
+
+function isRecord(value: unknown): value is JsonSchemaRecord {
+  return typeof value === 'object' && value !== null;
+}
+
+function escapeStringLiteral(str: string): string {
+  return str
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r');
+}
+
+function quotePropertyKey(key: string): string {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : `'${escapeStringLiteral(key)}'`;
+}
+
+function renderLiteral(value: unknown): string {
+  if (typeof value === 'string') {
+    return `'${escapeStringLiteral(value)}'`;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value);
+  }
+  if (value === null) {
+    return 'null';
+  }
+  return 'unknown';
+}
+
+function renderUnion(items: readonly unknown[], depth: number): string {
+  const rendered = items.map((item) => render(item, depth));
+  return rendered.join(' | ');
+}
+
+function renderObjectType(schema: JsonSchemaRecord, depth: number): string {
+  const properties = isRecord(schema['properties']) ? schema['properties'] : {};
+  const required = Array.isArray(schema['required'])
+    ? new Set(schema['required'].filter((key): key is string => typeof key === 'string'))
+    : new Set<string>();
+  const keys = Object.keys(properties).sort((left, right) => left.localeCompare(right));
+
+  if (keys.length === 0) {
+    const additionalProperties = schema['additionalProperties'];
+    if (additionalProperties === true || additionalProperties === undefined) {
+      return 'Record<string, unknown>';
+    }
+    return `Record<string, ${render(additionalProperties, depth)}>`;
+  }
+
+  const renderedProperties = keys.map((key) => {
+    const valueSchema = (properties as JsonSchemaRecord)[key];
+    const optionalMarker = required.has(key) ? '' : '?';
+    return `${quotePropertyKey(key)}${optionalMarker}: ${render(valueSchema, depth)}`;
+  });
+
+  return `{ ${renderedProperties.join('; ')} }`;
+}
+
+function renderArrayType(schema: JsonSchemaRecord, depth: number): string {
+  if (Array.isArray(schema['items'])) {
+    return `readonly [${schema['items'].map((item) => render(item, depth)).join(', ')}]`;
+  }
+
+  if (schema['items'] !== undefined) {
+    const itemType = render(schema['items'], depth);
+    const needsParens = itemType.includes(' | ') || itemType.includes(' & ');
+    return needsParens ? `(${itemType})[]` : `${itemType}[]`;
+  }
+
+  return 'unknown[]';
+}
+
+function render(schema: unknown, depth: number): string {
+  if (depth > MAX_DEPTH || !isRecord(schema)) {
+    return 'JsonValue';
+  }
+
+  const nextDepth = depth + 1;
+
+  if ('const' in schema) {
+    return renderLiteral(schema['const']);
+  }
+
+  if (Array.isArray(schema['enum'])) {
+    return schema['enum'].map((value) => renderLiteral(value)).join(' | ');
+  }
+
+  if (Array.isArray(schema['oneOf'])) {
+    return renderUnion(schema['oneOf'], nextDepth);
+  }
+
+  if (Array.isArray(schema['anyOf'])) {
+    return renderUnion(schema['anyOf'], nextDepth);
+  }
+
+  if (Array.isArray(schema['allOf'])) {
+    return schema['allOf'].map((item) => render(item, nextDepth)).join(' & ');
+  }
+
+  if (Array.isArray(schema['type'])) {
+    return schema['type'].map((item) => render({ ...schema, type: item }, nextDepth)).join(' | ');
+  }
+
+  switch (schema['type']) {
+    case 'string':
+      return 'string';
+    case 'number':
+    case 'integer':
+      return 'number';
+    case 'boolean':
+      return 'boolean';
+    case 'null':
+      return 'null';
+    case 'array':
+      return renderArrayType(schema, nextDepth);
+    case 'object':
+      return renderObjectType(schema, nextDepth);
+    default:
+      break;
+  }
+
+  return 'JsonValue';
+}
+
+export function renderTypeScriptTypeFromJsonSchema(schema: unknown): string {
+  return render(schema, 0);
+}