@prisma-next/adapter-postgres 0.3.0-dev.6 → 0.3.0-dev.63

package/src/core/default-normalizer.ts

@@ -0,0 +1,90 @@
+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 TIMESTAMP_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP|clock_timestamp\s*\(\s*\))$/i;
+const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
+const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
+const TRUE_PATTERN = /^true$/i;
+const FALSE_PATTERN = /^false$/i;
+const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
+const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
+
+/**
+ * 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 (currently unused, reserved for future type-aware parsing)
+ * @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()' };
+  }
+
+  // now() / CURRENT_TIMESTAMP / clock_timestamp()
+  if (TIMESTAMP_PATTERN.test(trimmed)) {
+    return { kind: 'function', expression: 'now()' };
+  }
+
+  // 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()' };
+  }
+
+  // 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 } };
+    }
+    return { kind: 'literal', value: Number(trimmed) };
+  }
+
+  // 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 };
+}

package/src/core/descriptor-meta.ts

@@ -1,3 +1,95 @@
+import type { CodecControlHooks } from '@prisma-next/family-sql/control';
+import {
+  PG_BIT_CODEC_ID,
+  PG_BOOL_CODEC_ID,
+  PG_CHAR_CODEC_ID,
+  PG_ENUM_CODEC_ID,
+  PG_FLOAT_CODEC_ID,
+  PG_FLOAT4_CODEC_ID,
+  PG_FLOAT8_CODEC_ID,
+  PG_INT_CODEC_ID,
+  PG_INT2_CODEC_ID,
+  PG_INT4_CODEC_ID,
+  PG_INT8_CODEC_ID,
+  PG_INTERVAL_CODEC_ID,
+  PG_JSON_CODEC_ID,
+  PG_JSONB_CODEC_ID,
+  PG_NUMERIC_CODEC_ID,
+  PG_TEXT_CODEC_ID,
+  PG_TIME_CODEC_ID,
+  PG_TIMESTAMP_CODEC_ID,
+  PG_TIMESTAMPTZ_CODEC_ID,
+  PG_TIMETZ_CODEC_ID,
+  PG_VARBIT_CODEC_ID,
+  PG_VARCHAR_CODEC_ID,
+  SQL_CHAR_CODEC_ID,
+  SQL_FLOAT_CODEC_ID,
+  SQL_INT_CODEC_ID,
+  SQL_VARCHAR_CODEC_ID,
+} from './codec-ids';
+import { pgEnumControlHooks } from './enum-control-hooks';
+import { renderTypeScriptTypeFromJsonSchema } from './json-schema-type-expression';
+import { expandParameterizedNativeType } from './parameterized-types';
+
+// ============================================================================
+// Helper functions for reducing boilerplate
+// ============================================================================
+
+/** Creates a type import spec for codec types */
+const codecTypeImport = (named: string) =>
+  ({
+    package: '@prisma-next/adapter-postgres/codec-types',
+    named,
+    alias: named,
+  }) as const;
+
+/** Creates a precision-based TypeScript type renderer for temporal types */
+const precisionRenderer = (typeName: string) =>
+  ({
+    kind: 'function',
+    render: (params: Record<string, unknown>) => {
+      const precision = params['precision'];
+      return typeof precision === 'number' ? `${typeName}<${precision}>` : typeName;
+    },
+  }) as const;
+
+/** Creates control hooks with just expandNativeType for parameterized types */
+const parameterizedTypeHooks: CodecControlHooks = {
+  expandNativeType: expandParameterizedNativeType,
+};
+
+/**
+ * Validates that a type expression string is safe to embed in generated .d.ts files.
+ * Rejects expressions containing patterns that could inject executable code.
+ */
+function isSafeTypeExpression(expr: string): boolean {
+  return !/import\s*\(|require\s*\(|declare\s|export\s|eval\s*\(/.test(expr);
+}
+
+function renderJsonTypeExpression(params: Record<string, unknown>): string {
+  const typeName = params['type'];
+  if (typeof typeName === 'string' && typeName.trim().length > 0) {
+    const trimmed = typeName.trim();
+    if (!isSafeTypeExpression(trimmed)) {
+      return 'JsonValue';
+    }
+    return trimmed;
+  }
+  const schema = params['schemaJson'];
+  if (schema && typeof schema === 'object') {
+    const rendered = renderTypeScriptTypeFromJsonSchema(schema);
+    if (!isSafeTypeExpression(rendered)) {
+      return 'JsonValue';
+    }
+    return rendered;
+  }
+  return 'JsonValue';
+}
+
+// ============================================================================
+// Descriptor metadata
+// ============================================================================
+
 export const postgresAdapterDescriptorMeta = {
   kind: 'adapter',
   familyId: 'sql',
@@ -12,6 +104,9 @@ export const postgresAdapterDescriptorMeta = {
       jsonAgg: true,
       returning: true,
     },
+    sql: {
+      enums: true,
+    },
   },
   types: {
     codecTypes: {
@@ -20,22 +115,139 @@ export const postgresAdapterDescriptorMeta = {
         named: 'CodecTypes',
         alias: 'PgTypes',
       },
+      parameterized: {
+        [SQL_CHAR_CODEC_ID]: 'Char<{{length}}>',
+        [SQL_VARCHAR_CODEC_ID]: 'Varchar<{{length}}>',
+        [PG_CHAR_CODEC_ID]: 'Char<{{length}}>',
+        [PG_VARCHAR_CODEC_ID]: 'Varchar<{{length}}>',
+        [PG_NUMERIC_CODEC_ID]: {
+          kind: 'function',
+          render: (params: Record<string, unknown>) => {
+            const precision = params['precision'];
+            if (typeof precision !== 'number') {
+              throw new Error('pg/numeric@1 renderer expects precision');
+            }
+            const scale = params['scale'];
+            return typeof scale === 'number'
+              ? `Numeric<${precision}, ${scale}>`
+              : `Numeric<${precision}>`;
+          },
+        },
+        [PG_BIT_CODEC_ID]: 'Bit<{{length}}>',
+        [PG_VARBIT_CODEC_ID]: 'VarBit<{{length}}>',
+        [PG_TIMESTAMP_CODEC_ID]: precisionRenderer('Timestamp'),
+        [PG_TIMESTAMPTZ_CODEC_ID]: precisionRenderer('Timestamptz'),
+        [PG_TIME_CODEC_ID]: precisionRenderer('Time'),
+        [PG_TIMETZ_CODEC_ID]: precisionRenderer('Timetz'),
+        [PG_INTERVAL_CODEC_ID]: precisionRenderer('Interval'),
+        [PG_ENUM_CODEC_ID]: {
+          kind: 'function',
+          render: (params: Record<string, unknown>) => {
+            const values = params['values'];
+            if (!Array.isArray(values)) {
+              throw new Error('pg/enum@1 renderer expects values array');
+            }
+            return values.map((value) => `'${String(value).replace(/'/g, "\\'")}'`).join(' | ');
+          },
+        },
+        [PG_JSON_CODEC_ID]: {
+          kind: 'function',
+          render: renderJsonTypeExpression,
+        },
+        [PG_JSONB_CODEC_ID]: {
+          kind: 'function',
+          render: renderJsonTypeExpression,
+        },
+      },
+      typeImports: [
+        {
+          package: '@prisma-next/adapter-postgres/codec-types',
+          named: 'JsonValue',
+          alias: 'JsonValue',
+        },
+        codecTypeImport('Char'),
+        codecTypeImport('Varchar'),
+        codecTypeImport('Numeric'),
+        codecTypeImport('Bit'),
+        codecTypeImport('VarBit'),
+        codecTypeImport('Timestamp'),
+        codecTypeImport('Timestamptz'),
+        codecTypeImport('Time'),
+        codecTypeImport('Timetz'),
+        codecTypeImport('Interval'),
+      ],
+      controlPlaneHooks: {
+        [SQL_CHAR_CODEC_ID]: parameterizedTypeHooks,
+        [SQL_VARCHAR_CODEC_ID]: parameterizedTypeHooks,
+        [PG_CHAR_CODEC_ID]: parameterizedTypeHooks,
+        [PG_VARCHAR_CODEC_ID]: parameterizedTypeHooks,
+        [PG_NUMERIC_CODEC_ID]: parameterizedTypeHooks,
+        [PG_BIT_CODEC_ID]: parameterizedTypeHooks,
+        [PG_VARBIT_CODEC_ID]: parameterizedTypeHooks,
+        [PG_TIMESTAMP_CODEC_ID]: parameterizedTypeHooks,
+        [PG_TIMESTAMPTZ_CODEC_ID]: parameterizedTypeHooks,
+        [PG_TIME_CODEC_ID]: parameterizedTypeHooks,
+        [PG_TIMETZ_CODEC_ID]: parameterizedTypeHooks,
+        [PG_INTERVAL_CODEC_ID]: parameterizedTypeHooks,
+        [PG_ENUM_CODEC_ID]: pgEnumControlHooks,
+      },
     },
     storage: [
-      { typeId: 'pg/text@1', familyId: 'sql', targetId: 'postgres', nativeType: 'text' },
-      { typeId: 'pg/int4@1', familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },
-      { typeId: 'pg/int2@1', familyId: 'sql', targetId: 'postgres', nativeType: 'int2' },
-      { typeId: 'pg/int8@1', familyId: 'sql', targetId: 'postgres', nativeType: 'int8' },
-      { typeId: 'pg/float4@1', familyId: 'sql', targetId: 'postgres', nativeType: 'float4' },
-      { typeId: 'pg/float8@1', familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },
-      { typeId: 'pg/timestamp@1', familyId: 'sql', targetId: 'postgres', nativeType: 'timestamp' },
+      { typeId: PG_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },
+      { typeId: SQL_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },
+      {
+        typeId: SQL_VARCHAR_CODEC_ID,
+        familyId: 'sql',
+        targetId: 'postgres',
+        nativeType: 'character varying',
+      },
+      { typeId: SQL_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },
+      { typeId: SQL_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },
+      { typeId: PG_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },
+      {
+        typeId: PG_VARCHAR_CODEC_ID,
+        familyId: 'sql',
+        targetId: 'postgres',
+        nativeType: 'character varying',
+      },
+      { typeId: PG_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },
+      { typeId: PG_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },
+      { typeId: PG_INT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },
+      { typeId: PG_INT2_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int2' },
+      { typeId: PG_INT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int8' },
+      { typeId: PG_FLOAT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float4' },
+      { typeId: PG_FLOAT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },
+      { typeId: PG_NUMERIC_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'numeric' },
       {
-        typeId: 'pg/timestamptz@1',
+        typeId: PG_TIMESTAMP_CODEC_ID,
+        familyId: 'sql',
+        targetId: 'postgres',
+        nativeType: 'timestamp',
+      },
+      {
+        typeId: PG_TIMESTAMPTZ_CODEC_ID,
         familyId: 'sql',
         targetId: 'postgres',
         nativeType: 'timestamptz',
       },
-      { typeId: 'pg/bool@1', familyId: 'sql', targetId: 'postgres', nativeType: 'bool' },
+      { typeId: PG_TIME_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'time' },
+      { typeId: PG_TIMETZ_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'timetz' },
+      { typeId: PG_BOOL_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bool' },
+      { typeId: PG_BIT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bit' },
+      {
+        typeId: PG_VARBIT_CODEC_ID,
+        familyId: 'sql',
+        targetId: 'postgres',
+        nativeType: 'bit varying',
+      },
+      {
+        typeId: PG_INTERVAL_CODEC_ID,
+        familyId: 'sql',
+        targetId: 'postgres',
+        nativeType: 'interval',
+      },
+      { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },
+      { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },
     ],
   },
 } as const;