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

package/src/core/descriptor-meta.ts

@@ -1,3 +1,168 @@
+import type { CodecControlHooks, ExpandNativeTypeInput } 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';
+
+// ============================================================================
+// 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;
+
+function isPositiveInteger(value: unknown): value is number {
+  return (
+    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value > 0
+  );
+}
+
+function isNonNegativeInteger(value: unknown): value is number {
+  return (
+    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0
+  );
+}
+
+function expandLength({ nativeType, typeParams }: ExpandNativeTypeInput): string {
+  if (!typeParams || !('length' in typeParams)) {
+    return nativeType;
+  }
+  const length = typeParams['length'];
+  if (!isPositiveInteger(length)) {
+    throw new Error(
+      `Invalid "length" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(length)}`,
+    );
+  }
+  return `${nativeType}(${length})`;
+}
+
+function expandPrecision({ nativeType, typeParams }: ExpandNativeTypeInput): string {
+  if (!typeParams || !('precision' in typeParams)) {
+    return nativeType;
+  }
+  const precision = typeParams['precision'];
+  if (!isPositiveInteger(precision)) {
+    throw new Error(
+      `Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`,
+    );
+  }
+  return `${nativeType}(${precision})`;
+}
+
+function expandNumeric({ nativeType, typeParams }: ExpandNativeTypeInput): string {
+  const hasPrecision = typeParams && 'precision' in typeParams;
+  const hasScale = typeParams && 'scale' in typeParams;
+
+  if (!hasPrecision && !hasScale) {
+    return nativeType;
+  }
+
+  if (!hasPrecision && hasScale) {
+    throw new Error(
+      `Invalid type parameters for "${nativeType}": "scale" requires "precision" to be specified`,
+    );
+  }
+
+  if (hasPrecision) {
+    const precision = typeParams['precision'];
+    if (!isPositiveInteger(precision)) {
+      throw new Error(
+        `Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`,
+      );
+    }
+    if (hasScale) {
+      const scale = typeParams['scale'];
+      if (!isNonNegativeInteger(scale)) {
+        throw new Error(
+          `Invalid "scale" type parameter for "${nativeType}": expected a non-negative integer, got ${JSON.stringify(scale)}`,
+        );
+      }
+      return `${nativeType}(${precision},${scale})`;
+    }
+    return `${nativeType}(${precision})`;
+  }
+
+  return nativeType;
+}
+
+const lengthHooks: CodecControlHooks = { expandNativeType: expandLength };
+const precisionHooks: CodecControlHooks = { expandNativeType: expandPrecision };
+const numericHooks: CodecControlHooks = { expandNativeType: expandNumeric };
+const identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) => nativeType };
+
+/**
+ * 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 +177,9 @@ export const postgresAdapterDescriptorMeta = {
       jsonAgg: true,
       returning: true,
     },
+    sql: {
+      enums: true,
+    },
   },
   types: {
     codecTypes: {
@@ -20,22 +188,141 @@ 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]: lengthHooks,
+        [SQL_VARCHAR_CODEC_ID]: lengthHooks,
+        [PG_CHAR_CODEC_ID]: lengthHooks,
+        [PG_VARCHAR_CODEC_ID]: lengthHooks,
+        [PG_NUMERIC_CODEC_ID]: numericHooks,
+        [PG_BIT_CODEC_ID]: lengthHooks,
+        [PG_VARBIT_CODEC_ID]: lengthHooks,
+        [PG_TIMESTAMP_CODEC_ID]: precisionHooks,
+        [PG_TIMESTAMPTZ_CODEC_ID]: precisionHooks,
+        [PG_TIME_CODEC_ID]: precisionHooks,
+        [PG_TIMETZ_CODEC_ID]: precisionHooks,
+        [PG_INTERVAL_CODEC_ID]: precisionHooks,
+        [PG_ENUM_CODEC_ID]: pgEnumControlHooks,
+        [PG_JSON_CODEC_ID]: identityHooks,
+        [PG_JSONB_CODEC_ID]: identityHooks,
+      },
     },
     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;