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

package/src/exports/column-types.ts

@@ -6,48 +6,272 @@
  */
 
 import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
+import {
+  PG_BIT_CODEC_ID,
+  PG_BOOL_CODEC_ID,
+  PG_ENUM_CODEC_ID,
+  PG_FLOAT4_CODEC_ID,
+  PG_FLOAT8_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,
+  SQL_CHAR_CODEC_ID,
+  SQL_VARCHAR_CODEC_ID,
+} from '../core/codec-ids';
+import {
+  extractStandardSchemaOutputJsonSchema,
+  extractStandardSchemaTypeExpression,
+  isStandardSchemaLike,
+  type StandardSchemaLike,
+} from '../core/standard-schema';
 
 export const textColumn: ColumnTypeDescriptor = {
-  codecId: 'pg/text@1',
+  codecId: PG_TEXT_CODEC_ID,
   nativeType: 'text',
 } as const;
 
+export function charColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: { readonly length: number };
+} {
+  return {
+    codecId: SQL_CHAR_CODEC_ID,
+    nativeType: 'character',
+    typeParams: { length },
+  } as const;
+}
+
+export function varcharColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: { readonly length: number };
+} {
+  return {
+    codecId: SQL_VARCHAR_CODEC_ID,
+    nativeType: 'character varying',
+    typeParams: { length },
+  } as const;
+}
+
 export const int4Column: ColumnTypeDescriptor = {
-  codecId: 'pg/int4@1',
+  codecId: PG_INT4_CODEC_ID,
   nativeType: 'int4',
 } as const;
 
 export const int2Column: ColumnTypeDescriptor = {
-  codecId: 'pg/int2@1',
+  codecId: PG_INT2_CODEC_ID,
   nativeType: 'int2',
 } as const;
 
 export const int8Column: ColumnTypeDescriptor = {
-  codecId: 'pg/int8@1',
+  codecId: PG_INT8_CODEC_ID,
   nativeType: 'int8',
 } as const;
 
 export const float4Column: ColumnTypeDescriptor = {
-  codecId: 'pg/float4@1',
+  codecId: PG_FLOAT4_CODEC_ID,
   nativeType: 'float4',
 } as const;
 
 export const float8Column: ColumnTypeDescriptor = {
-  codecId: 'pg/float8@1',
+  codecId: PG_FLOAT8_CODEC_ID,
   nativeType: 'float8',
 } as const;
 
+export function numericColumn(
+  precision: number,
+  scale?: number,
+): ColumnTypeDescriptor & {
+  readonly typeParams: { readonly precision: number; readonly scale?: number };
+} {
+  return {
+    codecId: PG_NUMERIC_CODEC_ID,
+    nativeType: 'numeric',
+    typeParams: scale === undefined ? { precision } : { precision, scale },
+  } as const;
+}
+
 export const timestampColumn: ColumnTypeDescriptor = {
-  codecId: 'pg/timestamp@1',
+  codecId: PG_TIMESTAMP_CODEC_ID,
   nativeType: 'timestamp',
 } as const;
 
 export const timestamptzColumn: ColumnTypeDescriptor = {
-  codecId: 'pg/timestamptz@1',
+  codecId: PG_TIMESTAMPTZ_CODEC_ID,
   nativeType: 'timestamptz',
 } as const;
 
+export function timeColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: { readonly precision: number };
+} {
+  return {
+    codecId: PG_TIME_CODEC_ID,
+    nativeType: 'time',
+    ...(precision === undefined ? {} : { typeParams: { precision } }),
+  } as const;
+}
+
+export function timetzColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: { readonly precision: number };
+} {
+  return {
+    codecId: PG_TIMETZ_CODEC_ID,
+    nativeType: 'timetz',
+    ...(precision === undefined ? {} : { typeParams: { precision } }),
+  } as const;
+}
+
 export const boolColumn: ColumnTypeDescriptor = {
-  codecId: 'pg/bool@1',
+  codecId: PG_BOOL_CODEC_ID,
   nativeType: 'bool',
 } as const;
+
+export function bitColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: { readonly length: number };
+} {
+  return {
+    codecId: PG_BIT_CODEC_ID,
+    nativeType: 'bit',
+    typeParams: { length },
+  } as const;
+}
+
+export function varbitColumn(length: number): ColumnTypeDescriptor & {
+  readonly typeParams: { readonly length: number };
+} {
+  return {
+    codecId: PG_VARBIT_CODEC_ID,
+    nativeType: 'bit varying',
+    typeParams: { length },
+  } as const;
+}
+
+export function intervalColumn(precision?: number): ColumnTypeDescriptor & {
+  readonly typeParams?: { readonly precision: number };
+} {
+  return {
+    codecId: PG_INTERVAL_CODEC_ID,
+    nativeType: 'interval',
+    ...(precision === undefined ? {} : { typeParams: { precision } }),
+  } as const;
+}
+
+export const jsonColumn: ColumnTypeDescriptor = {
+  codecId: PG_JSON_CODEC_ID,
+  nativeType: 'json',
+} as const;
+
+export const jsonbColumn: ColumnTypeDescriptor = {
+  codecId: PG_JSONB_CODEC_ID,
+  nativeType: 'jsonb',
+} as const;
+
+type JsonSchemaTypeParams = {
+  readonly schemaJson: Record<string, unknown>;
+  readonly type?: string;
+};
+
+function createJsonTypeParams(schema: StandardSchemaLike): JsonSchemaTypeParams {
+  const outputSchema = extractStandardSchemaOutputJsonSchema(schema);
+  if (!outputSchema) {
+    throw new Error('JSON schema must expose ~standard.jsonSchema.output()');
+  }
+
+  const expression = extractStandardSchemaTypeExpression(schema);
+  if (expression) {
+    return { schemaJson: outputSchema, type: expression };
+  }
+
+  return { schemaJson: outputSchema };
+}
+
+/**
+ * Typed column descriptor for JSON/JSONB columns with Standard Schema.
+ *
+ * `typeParams.schemaJson` carries the runtime JSON Schema payload (serializable record)
+ * used by the emitter to render TypeScript type expressions in contract.d.ts.
+ *
+ * `typeParams.schema` is a phantom-only key: at runtime it does not exist, but at the
+ * type level it preserves the original `TSchema` so that `ResolveStandardSchemaOutput<P>`
+ * in codec-types.ts can resolve the output type via `~standard.types.output` or `.infer`.
+ */
+type TypedColumnDescriptor<TSchema extends StandardSchemaLike> = ColumnTypeDescriptor & {
+  readonly typeParams: JsonSchemaTypeParams & { readonly schema: TSchema };
+};
+
+function createJsonColumnFactory(
+  codecId: string,
+  nativeType: string,
+  staticDescriptor: ColumnTypeDescriptor,
+) {
+  return <TSchema extends StandardSchemaLike>(schema?: TSchema): ColumnTypeDescriptor => {
+    if (!schema) {
+      return staticDescriptor;
+    }
+
+    if (!isStandardSchemaLike(schema)) {
+      throw new Error(`${nativeType}(schema) expects a Standard Schema value`);
+    }
+
+    return {
+      codecId,
+      nativeType,
+      // At runtime, typeParams only contains { schemaJson, type? }.
+      // The `schema` key exists only at the type level (phantom) so that
+      // `ResolveStandardSchemaOutput<P>` in codec-types.ts can resolve the
+      // schema's output type via `~standard.types.output` or `.infer`.
+      typeParams: createJsonTypeParams(schema) as JsonSchemaTypeParams & {
+        readonly schema: TSchema;
+      },
+    };
+  };
+}
+
+const _json = createJsonColumnFactory(PG_JSON_CODEC_ID, 'json', jsonColumn);
+const _jsonb = createJsonColumnFactory(PG_JSONB_CODEC_ID, 'jsonb', jsonbColumn);
+
+export function json(): ColumnTypeDescriptor;
+export function json<TSchema extends StandardSchemaLike>(
+  schema: TSchema,
+): TypedColumnDescriptor<TSchema>;
+export function json<TSchema extends StandardSchemaLike>(schema?: TSchema): ColumnTypeDescriptor {
+  return _json(schema);
+}
+
+export function jsonb(): ColumnTypeDescriptor;
+export function jsonb<TSchema extends StandardSchemaLike>(
+  schema: TSchema,
+): TypedColumnDescriptor<TSchema>;
+export function jsonb<TSchema extends StandardSchemaLike>(schema?: TSchema): ColumnTypeDescriptor {
+  return _jsonb(schema);
+}
+
+export function enumType<const Values extends readonly string[]>(
+  name: string,
+  values: Values,
+): StorageTypeInstance & { readonly typeParams: { readonly values: Values } } {
+  return {
+    codecId: PG_ENUM_CODEC_ID,
+    nativeType: name,
+    typeParams: { values },
+  } as const;
+}
+
+export function enumColumn<TypeName extends string>(
+  typeName: TypeName,
+  nativeType: string,
+): ColumnTypeDescriptor & { readonly typeRef: TypeName } {
+  return {
+    codecId: PG_ENUM_CODEC_ID,
+    nativeType,
+    typeRef: typeName,
+  };
+}

package/src/exports/control.ts

@@ -1,20 +1,27 @@
-import type { ControlAdapterDescriptor } from '@prisma-next/core-control-plane/types';
+import type { SqlControlAdapterDescriptor } from '@prisma-next/family-sql/control';
 import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
 import { PostgresControlAdapter } from '../core/control-adapter';
+import { parsePostgresDefault } from '../core/default-normalizer';
 import { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';
+import { expandParameterizedNativeType } from '../core/parameterized-types';
+import { escapeLiteral, qualifyName, quoteIdentifier, SqlEscapeError } from '../core/sql-utils';
 
-/**
- * Postgres adapter descriptor for CLI config.
- */
-const postgresAdapterDescriptor: ControlAdapterDescriptor<
-  'sql',
-  'postgres',
-  SqlControlAdapter<'postgres'>
-> = {
+const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'> = {
   ...postgresAdapterDescriptorMeta,
+  operationSignatures: () => [],
   create(): SqlControlAdapter<'postgres'> {
     return new PostgresControlAdapter();
   },
 };
 
 export default postgresAdapterDescriptor;
+
+export { normalizeSchemaNativeType } from '../core/control-adapter';
+export {
+  escapeLiteral,
+  expandParameterizedNativeType,
+  parsePostgresDefault,
+  qualifyName,
+  quoteIdentifier,
+  SqlEscapeError,
+};

package/src/exports/runtime.ts

@@ -1,32 +1,75 @@
+import type { RuntimeAdapterInstance } from '@prisma-next/core-execution-plane/types';
+import type { Adapter, CodecRegistry, QueryAst } from '@prisma-next/sql-relational-core/ast';
+import { createCodecRegistry } from '@prisma-next/sql-relational-core/ast';
 import type {
-  RuntimeAdapterDescriptor,
-  RuntimeAdapterInstance,
-} from '@prisma-next/core-execution-plane/types';
-import type { Adapter, QueryAst } from '@prisma-next/sql-relational-core/ast';
+  RuntimeParameterizedCodecDescriptor,
+  SqlRuntimeAdapterDescriptor,
+} from '@prisma-next/sql-runtime';
+import { type as arktype } from 'arktype';
 import { createPostgresAdapter } from '../core/adapter';
+import { PG_JSON_CODEC_ID, PG_JSONB_CODEC_ID } from '../core/codec-ids';
+import { codecDefinitions } from '../core/codecs';
 import { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';
+import {
+  compileJsonSchemaValidator,
+  type JsonSchemaValidateFn,
+} from '../core/json-schema-validator';
 import type { PostgresContract, PostgresLoweredStatement } from '../core/types';
 
-/**
- * SQL runtime adapter interface for Postgres.
- * Extends RuntimeAdapterInstance with SQL-specific adapter methods.
- */
 export interface SqlRuntimeAdapter
   extends RuntimeAdapterInstance<'sql', 'postgres'>,
     Adapter<QueryAst, PostgresContract, PostgresLoweredStatement> {}
 
+function createPostgresCodecRegistry(): CodecRegistry {
+  const registry = createCodecRegistry();
+  for (const definition of Object.values(codecDefinitions)) {
+    registry.register(definition.codec);
+  }
+  return registry;
+}
+
+const jsonTypeParamsSchema = arktype({
+  schemaJson: 'object',
+  'type?': 'string',
+});
+
+/** The inferred type params shape from the arktype schema. */
+type JsonTypeParams = typeof jsonTypeParamsSchema.infer;
+
 /**
- * Postgres adapter descriptor for runtime plane.
+ * Helper returned by the JSON/JSONB `init` hook.
+ * Contains a compiled JSON Schema validate function for runtime conformance checks.
  */
-const postgresRuntimeAdapterDescriptor: RuntimeAdapterDescriptor<
-  'sql',
-  'postgres',
-  SqlRuntimeAdapter
-> = {
-  ...postgresAdapterDescriptorMeta,
-  create(): SqlRuntimeAdapter {
-    return createPostgresAdapter();
+export type JsonCodecHelper = { readonly validate: JsonSchemaValidateFn };
+
+function initJsonCodecHelper(params: JsonTypeParams): JsonCodecHelper {
+  return { validate: compileJsonSchemaValidator(params.schemaJson as Record<string, unknown>) };
+}
+
+const parameterizedCodecDescriptors = [
+  {
+    codecId: PG_JSON_CODEC_ID,
+    paramsSchema: jsonTypeParamsSchema,
+    init: initJsonCodecHelper,
   },
-};
+  {
+    codecId: PG_JSONB_CODEC_ID,
+    paramsSchema: jsonTypeParamsSchema,
+    init: initJsonCodecHelper,
+  },
+] as const satisfies ReadonlyArray<
+  RuntimeParameterizedCodecDescriptor<JsonTypeParams, JsonCodecHelper>
+>;
+
+const postgresRuntimeAdapterDescriptor: SqlRuntimeAdapterDescriptor<'postgres', SqlRuntimeAdapter> =
+  {
+    ...postgresAdapterDescriptorMeta,
+    codecs: createPostgresCodecRegistry,
+    operationSignatures: () => [],
+    parameterizedCodecs: () => parameterizedCodecDescriptors,
+    create(): SqlRuntimeAdapter {
+      return createPostgresAdapter();
+    },
+  };
 
 export default postgresRuntimeAdapterDescriptor;

package/dist/chunk-HD5YISNQ.js

@@ -1,47 +0,0 @@
-// src/core/descriptor-meta.ts
-var postgresAdapterDescriptorMeta = {
-  kind: "adapter",
-  familyId: "sql",
-  targetId: "postgres",
-  id: "postgres",
-  version: "0.0.1",
-  capabilities: {
-    postgres: {
-      orderBy: true,
-      limit: true,
-      lateral: true,
-      jsonAgg: true,
-      returning: true
-    }
-  },
-  types: {
-    codecTypes: {
-      import: {
-        package: "@prisma-next/adapter-postgres/codec-types",
-        named: "CodecTypes",
-        alias: "PgTypes"
-      }
-    },
-    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/timestamptz@1",
-        familyId: "sql",
-        targetId: "postgres",
-        nativeType: "timestamptz"
-      },
-      { typeId: "pg/bool@1", familyId: "sql", targetId: "postgres", nativeType: "bool" }
-    ]
-  }
-};
-
-export {
-  postgresAdapterDescriptorMeta
-};
-//# sourceMappingURL=chunk-HD5YISNQ.js.map

package/dist/chunk-HD5YISNQ.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["export const postgresAdapterDescriptorMeta = {\n  kind: 'adapter',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      orderBy: true,\n      limit: true,\n      lateral: true,\n      jsonAgg: true,\n      returning: true,\n    },\n  },\n  types: {\n    codecTypes: {\n      import: {\n        package: '@prisma-next/adapter-postgres/codec-types',\n        named: 'CodecTypes',\n        alias: 'PgTypes',\n      },\n    },\n    storage: [\n      { typeId: 'pg/text@1', familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: 'pg/int4@1', familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: 'pg/int2@1', familyId: 'sql', targetId: 'postgres', nativeType: 'int2' },\n      { typeId: 'pg/int8@1', familyId: 'sql', targetId: 'postgres', nativeType: 'int8' },\n      { typeId: 'pg/float4@1', familyId: 'sql', targetId: 'postgres', nativeType: 'float4' },\n      { typeId: 'pg/float8@1', familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: 'pg/timestamp@1', familyId: 'sql', targetId: 'postgres', nativeType: 'timestamp' },\n      {\n        typeId: 'pg/timestamptz@1',\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamptz',\n      },\n      { typeId: 'pg/bool@1', familyId: 'sql', targetId: 'postgres', nativeType: 'bool' },\n    ],\n  },\n} as const;\n"],"mappings":";AAAO,IAAM,gCAAgC;AAAA,EAC3C,MAAM;AAAA,EACN,UAAU;AAAA,EACV,UAAU;AAAA,EACV,IAAI;AAAA,EACJ,SAAS;AAAA,EACT,cAAc;AAAA,IACZ,UAAU;AAAA,MACR,SAAS;AAAA,MACT,OAAO;AAAA,MACP,SAAS;AAAA,MACT,SAAS;AAAA,MACT,WAAW;AAAA,IACb;AAAA,EACF;AAAA,EACA,OAAO;AAAA,IACL,YAAY;AAAA,MACV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,QACP,OAAO;AAAA,MACT;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP,EAAE,QAAQ,aAAa,UAAU,OAAO,UAAU,YAAY,YAAY,OAAO;AAAA,MACjF,EAAE,QAAQ,aAAa,UAAU,OAAO,UAAU,YAAY,YAAY,OAAO;AAAA,MACjF,EAAE,QAAQ,aAAa,UAAU,OAAO,UAAU,YAAY,YAAY,OAAO;AAAA,MACjF,EAAE,QAAQ,aAAa,UAAU,OAAO,UAAU,YAAY,YAAY,OAAO;AAAA,MACjF,EAAE,QAAQ,eAAe,UAAU,OAAO,UAAU,YAAY,YAAY,SAAS;AAAA,MACrF,EAAE,QAAQ,eAAe,UAAU,OAAO,UAAU,YAAY,YAAY,SAAS;AAAA,MACrF,EAAE,QAAQ,kBAAkB,UAAU,OAAO,UAAU,YAAY,YAAY,YAAY;AAAA,MAC3F;AAAA,QACE,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,UAAU;AAAA,QACV,YAAY;AAAA,MACd;AAAA,MACA,EAAE,QAAQ,aAAa,UAAU,OAAO,UAAU,YAAY,YAAY,OAAO;AAAA,IACnF;AAAA,EACF;AACF;","names":[]}

package/dist/chunk-J3XSOAM2.js

@@ -1,162 +0,0 @@
-// src/core/codecs.ts
-import { codec, defineCodecs } from "@prisma-next/sql-relational-core/ast";
-var pgTextCodec = codec({
-  typeId: "pg/text@1",
-  targetTypes: ["text"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "text"
-        }
-      }
-    }
-  }
-});
-var pgInt4Codec = codec({
-  typeId: "pg/int4@1",
-  targetTypes: ["int4"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "integer"
-        }
-      }
-    }
-  }
-});
-var pgInt2Codec = codec({
-  typeId: "pg/int2@1",
-  targetTypes: ["int2"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "smallint"
-        }
-      }
-    }
-  }
-});
-var pgInt8Codec = codec({
-  typeId: "pg/int8@1",
-  targetTypes: ["int8"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "bigint"
-        }
-      }
-    }
-  }
-});
-var pgFloat4Codec = codec({
-  typeId: "pg/float4@1",
-  targetTypes: ["float4"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "real"
-        }
-      }
-    }
-  }
-});
-var pgFloat8Codec = codec({
-  typeId: "pg/float8@1",
-  targetTypes: ["float8"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "double precision"
-        }
-      }
-    }
-  }
-});
-var pgTimestampCodec = codec({
-  typeId: "pg/timestamp@1",
-  targetTypes: ["timestamp"],
-  encode: (value) => {
-    if (value instanceof Date) return value.toISOString();
-    if (typeof value === "string") return value;
-    return String(value);
-  },
-  decode: (wire) => {
-    if (typeof wire === "string") return wire;
-    if (wire instanceof Date) return wire.toISOString();
-    return String(wire);
-  },
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "timestamp without time zone"
-        }
-      }
-    }
-  }
-});
-var pgTimestamptzCodec = codec({
-  typeId: "pg/timestamptz@1",
-  targetTypes: ["timestamptz"],
-  encode: (value) => {
-    if (value instanceof Date) return value.toISOString();
-    if (typeof value === "string") return value;
-    return String(value);
-  },
-  decode: (wire) => {
-    if (typeof wire === "string") return wire;
-    if (wire instanceof Date) return wire.toISOString();
-    return String(wire);
-  },
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "timestamp with time zone"
-        }
-      }
-    }
-  }
-});
-var pgBoolCodec = codec({
-  typeId: "pg/bool@1",
-  targetTypes: ["bool"],
-  encode: (value) => value,
-  decode: (wire) => wire,
-  meta: {
-    db: {
-      sql: {
-        postgres: {
-          nativeType: "boolean"
-        }
-      }
-    }
-  }
-});
-var codecs = defineCodecs().add("text", pgTextCodec).add("int4", pgInt4Codec).add("int2", pgInt2Codec).add("int8", pgInt8Codec).add("float4", pgFloat4Codec).add("float8", pgFloat8Codec).add("timestamp", pgTimestampCodec).add("timestamptz", pgTimestamptzCodec).add("bool", pgBoolCodec);
-var codecDefinitions = codecs.codecDefinitions;
-var dataTypes = codecs.dataTypes;
-
-export {
-  codecDefinitions,
-  dataTypes
-};
-//# sourceMappingURL=chunk-J3XSOAM2.js.map

package/dist/chunk-J3XSOAM2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/codecs.ts"],"sourcesContent":["/**\n * Unified codec definitions for Postgres adapter.\n *\n * This file contains a single source of truth for all codec information:\n * - Scalar names\n * - Type IDs\n * - Codec implementations (runtime)\n * - Type information (compile-time)\n *\n * This structure is used both at runtime (to populate the registry) and\n * at compile time (to derive CodecTypes).\n */\n\nimport { codec, defineCodecs } from '@prisma-next/sql-relational-core/ast';\n\n// Create individual codec instances\nconst pgTextCodec = codec({\n  typeId: 'pg/text@1',\n  targetTypes: ['text'],\n  encode: (value: string): string => value,\n  decode: (wire: string): string => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'text',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt4Codec = codec<'pg/int4@1', number, number>({\n  typeId: 'pg/int4@1',\n  targetTypes: ['int4'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'integer',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt2Codec = codec<'pg/int2@1', number, number>({\n  typeId: 'pg/int2@1',\n  targetTypes: ['int2'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'smallint',\n        },\n      },\n    },\n  },\n});\n\nconst pgInt8Codec = codec<'pg/int8@1', number, number>({\n  typeId: 'pg/int8@1',\n  targetTypes: ['int8'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'bigint',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloat4Codec = codec<'pg/float4@1', number, number>({\n  typeId: 'pg/float4@1',\n  targetTypes: ['float4'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'real',\n        },\n      },\n    },\n  },\n});\n\nconst pgFloat8Codec = codec<'pg/float8@1', number, number>({\n  typeId: 'pg/float8@1',\n  targetTypes: ['float8'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'double precision',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimestampCodec = codec<'pg/timestamp@1', string | Date, string>({\n  typeId: 'pg/timestamp@1',\n  targetTypes: ['timestamp'],\n  encode: (value: string | Date): string => {\n    if (value instanceof Date) return value.toISOString();\n    if (typeof value === 'string') return value;\n    return String(value);\n  },\n  decode: (wire: string | Date): string => {\n    if (typeof wire === 'string') return wire;\n    if (wire instanceof Date) return wire.toISOString();\n    return String(wire);\n  },\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timestamp without time zone',\n        },\n      },\n    },\n  },\n});\n\nconst pgTimestamptzCodec = codec<'pg/timestamptz@1', string | Date, string>({\n  typeId: 'pg/timestamptz@1',\n  targetTypes: ['timestamptz'],\n  encode: (value: string | Date): string => {\n    if (value instanceof Date) return value.toISOString();\n    if (typeof value === 'string') return value;\n    return String(value);\n  },\n  decode: (wire: string | Date): string => {\n    if (typeof wire === 'string') return wire;\n    if (wire instanceof Date) return wire.toISOString();\n    return String(wire);\n  },\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'timestamp with time zone',\n        },\n      },\n    },\n  },\n});\n\nconst pgBoolCodec = codec<'pg/bool@1', boolean, boolean>({\n  typeId: 'pg/bool@1',\n  targetTypes: ['bool'],\n  encode: (value) => value,\n  decode: (wire) => wire,\n  meta: {\n    db: {\n      sql: {\n        postgres: {\n          nativeType: 'boolean',\n        },\n      },\n    },\n  },\n});\n\n// Build codec definitions using the builder DSL\nconst codecs = defineCodecs()\n  .add('text', pgTextCodec)\n  .add('int4', pgInt4Codec)\n  .add('int2', pgInt2Codec)\n  .add('int8', pgInt8Codec)\n  .add('float4', pgFloat4Codec)\n  .add('float8', pgFloat8Codec)\n  .add('timestamp', pgTimestampCodec)\n  .add('timestamptz', pgTimestamptzCodec)\n  .add('bool', pgBoolCodec);\n\n// Export derived structures directly from codecs builder\nexport const codecDefinitions = codecs.codecDefinitions;\nexport const dataTypes = codecs.dataTypes;\n\n// Export types derived from codecs builder\nexport type CodecTypes = typeof codecs.CodecTypes;\n"],"mappings":"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","names":[]}