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

package/src/core/control-adapter.ts

@@ -0,0 +1,375 @@
+import type { ControlDriverInstance } from '@prisma-next/core-control-plane/types';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import type {
+  PrimaryKey,
+  SqlColumnIR,
+  SqlForeignKeyIR,
+  SqlIndexIR,
+  SqlSchemaIR,
+  SqlTableIR,
+  SqlUniqueIR,
+} from '@prisma-next/sql-schema-ir/types';
+
+/**
+ * Postgres control plane adapter for control-plane operations like introspection.
+ * Provides target-specific implementations for control-plane domain actions.
+ */
+export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
+  readonly familyId = 'sql' as const;
+  readonly targetId = 'postgres' as const;
+  /**
+   * @deprecated Use targetId instead
+   */
+  readonly target = 'postgres' as const;
+
+  /**
+   * Introspects a Postgres database schema and returns a raw SqlSchemaIR.
+   *
+   * This is a pure schema discovery operation that queries the Postgres catalog
+   * and returns the schema structure without type mapping or contract enrichment.
+   * Type mapping and enrichment are handled separately by enrichment helpers.
+   *
+   * @param driver - ControlDriverInstance<'sql', 'postgres'> instance for executing queries
+   * @param contractIR - Optional contract IR for contract-guided introspection (filtering, optimization)
+   * @param schema - Schema name to introspect (defaults to 'public')
+   * @returns Promise resolving to SqlSchemaIR representing the live database schema
+   */
+  async introspect(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+    _contractIR?: unknown,
+    schema = 'public',
+  ): Promise<SqlSchemaIR> {
+    // Query tables
+    const tablesResult = await driver.query<{
+      table_name: string;
+    }>(
+      `SELECT table_name
+       FROM information_schema.tables
+       WHERE table_schema = $1
+         AND table_type = 'BASE TABLE'
+       ORDER BY table_name`,
+      [schema],
+    );
+
+    const tables: Record<string, SqlTableIR> = {};
+
+    for (const tableRow of tablesResult.rows) {
+      const tableName = tableRow.table_name;
+
+      // Query columns for this table
+      const columnsResult = await driver.query<{
+        column_name: string;
+        data_type: string;
+        udt_name: string;
+        is_nullable: string;
+        character_maximum_length: number | null;
+        numeric_precision: number | null;
+        numeric_scale: number | null;
+      }>(
+        `SELECT
+           column_name,
+           data_type,
+           udt_name,
+           is_nullable,
+           character_maximum_length,
+           numeric_precision,
+           numeric_scale
+         FROM information_schema.columns
+         WHERE table_schema = $1
+           AND table_name = $2
+         ORDER BY ordinal_position`,
+        [schema, tableName],
+      );
+
+      const columns: Record<string, SqlColumnIR> = {};
+      for (const colRow of columnsResult.rows) {
+        // Build native type string from catalog data
+        let nativeType = colRow.udt_name;
+        if (colRow.data_type === 'character varying' || colRow.data_type === 'character') {
+          if (colRow.character_maximum_length) {
+            nativeType = `${colRow.data_type}(${colRow.character_maximum_length})`;
+          } else {
+            nativeType = colRow.data_type;
+          }
+        } else if (colRow.data_type === 'numeric' || colRow.data_type === 'decimal') {
+          if (colRow.numeric_precision && colRow.numeric_scale !== null) {
+            nativeType = `${colRow.data_type}(${colRow.numeric_precision},${colRow.numeric_scale})`;
+          } else if (colRow.numeric_precision) {
+            nativeType = `${colRow.data_type}(${colRow.numeric_precision})`;
+          } else {
+            nativeType = colRow.data_type;
+          }
+        } else {
+          nativeType = colRow.udt_name || colRow.data_type;
+        }
+
+        columns[colRow.column_name] = {
+          name: colRow.column_name,
+          nativeType,
+          nullable: colRow.is_nullable === 'YES',
+        };
+      }
+
+      // Query primary key
+      const pkResult = await driver.query<{
+        constraint_name: string;
+        column_name: string;
+        ordinal_position: number;
+      }>(
+        `SELECT
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = $1
+           AND tc.table_name = $2
+           AND tc.constraint_type = 'PRIMARY KEY'
+         ORDER BY kcu.ordinal_position`,
+        [schema, tableName],
+      );
+
+      const primaryKeyColumns = pkResult.rows
+        .sort((a, b) => a.ordinal_position - b.ordinal_position)
+        .map((row) => row.column_name);
+      const primaryKey: PrimaryKey | undefined =
+        primaryKeyColumns.length > 0
+          ? {
+              columns: primaryKeyColumns,
+              ...(pkResult.rows[0]?.constraint_name
+                ? { name: pkResult.rows[0].constraint_name }
+                : {}),
+            }
+          : undefined;
+
+      // Query foreign keys
+      const fkResult = await driver.query<{
+        constraint_name: string;
+        column_name: string;
+        ordinal_position: number;
+        referenced_table_schema: string;
+        referenced_table_name: string;
+        referenced_column_name: string;
+      }>(
+        `SELECT
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position,
+           ccu.table_schema AS referenced_table_schema,
+           ccu.table_name AS referenced_table_name,
+           ccu.column_name AS referenced_column_name
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         JOIN information_schema.constraint_column_usage ccu
+           ON ccu.constraint_name = tc.constraint_name
+           AND ccu.table_schema = tc.table_schema
+         WHERE tc.table_schema = $1
+           AND tc.table_name = $2
+           AND tc.constraint_type = 'FOREIGN KEY'
+         ORDER BY tc.constraint_name, kcu.ordinal_position`,
+        [schema, tableName],
+      );
+
+      const foreignKeysMap = new Map<
+        string,
+        {
+          columns: string[];
+          referencedTable: string;
+          referencedColumns: string[];
+          name: string;
+        }
+      >();
+      for (const fkRow of fkResult.rows) {
+        const existing = foreignKeysMap.get(fkRow.constraint_name);
+        if (existing) {
+          // Multi-column FK - add column
+          existing.columns.push(fkRow.column_name);
+          existing.referencedColumns.push(fkRow.referenced_column_name);
+        } else {
+          foreignKeysMap.set(fkRow.constraint_name, {
+            columns: [fkRow.column_name],
+            referencedTable: fkRow.referenced_table_name,
+            referencedColumns: [fkRow.referenced_column_name],
+            name: fkRow.constraint_name,
+          });
+        }
+      }
+      const foreignKeys: readonly SqlForeignKeyIR[] = Array.from(foreignKeysMap.values()).map(
+        (fk) => ({
+          columns: Object.freeze([...fk.columns]) as readonly string[],
+          referencedTable: fk.referencedTable,
+          referencedColumns: Object.freeze([...fk.referencedColumns]) as readonly string[],
+          name: fk.name,
+        }),
+      );
+
+      // Query unique constraints (excluding PK)
+      const uniqueResult = await driver.query<{
+        constraint_name: string;
+        column_name: string;
+        ordinal_position: number;
+      }>(
+        `SELECT
+           tc.constraint_name,
+           kcu.column_name,
+           kcu.ordinal_position
+         FROM information_schema.table_constraints tc
+         JOIN information_schema.key_column_usage kcu
+           ON tc.constraint_name = kcu.constraint_name
+           AND tc.table_schema = kcu.table_schema
+           AND tc.table_name = kcu.table_name
+         WHERE tc.table_schema = $1
+           AND tc.table_name = $2
+           AND tc.constraint_type = 'UNIQUE'
+           AND tc.constraint_name NOT IN (
+             SELECT constraint_name
+             FROM information_schema.table_constraints
+             WHERE table_schema = $1
+               AND table_name = $2
+               AND constraint_type = 'PRIMARY KEY'
+           )
+         ORDER BY tc.constraint_name, kcu.ordinal_position`,
+        [schema, tableName],
+      );
+
+      const uniquesMap = new Map<
+        string,
+        {
+          columns: string[];
+          name: string;
+        }
+      >();
+      for (const uniqueRow of uniqueResult.rows) {
+        const existing = uniquesMap.get(uniqueRow.constraint_name);
+        if (existing) {
+          existing.columns.push(uniqueRow.column_name);
+        } else {
+          uniquesMap.set(uniqueRow.constraint_name, {
+            columns: [uniqueRow.column_name],
+            name: uniqueRow.constraint_name,
+          });
+        }
+      }
+      const uniques: readonly SqlUniqueIR[] = Array.from(uniquesMap.values()).map((uq) => ({
+        columns: Object.freeze([...uq.columns]) as readonly string[],
+        name: uq.name,
+      }));
+
+      // Query indexes (excluding PK and unique constraints)
+      const indexResult = await driver.query<{
+        indexname: string;
+        indisunique: boolean;
+        attname: string;
+        attnum: number;
+      }>(
+        `SELECT
+           i.indexname,
+           ix.indisunique,
+           a.attname,
+           a.attnum
+         FROM pg_indexes i
+         JOIN pg_class ic ON ic.relname = i.indexname
+         JOIN pg_namespace ins ON ins.oid = ic.relnamespace AND ins.nspname = $1
+         JOIN pg_index ix ON ix.indexrelid = ic.oid
+         JOIN pg_class t ON t.oid = ix.indrelid
+         JOIN pg_namespace tn ON tn.oid = t.relnamespace AND tn.nspname = $1
+         LEFT JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = ANY(ix.indkey) AND a.attnum > 0
+         WHERE i.schemaname = $1
+           AND i.tablename = $2
+           AND NOT EXISTS (
+             SELECT 1
+             FROM information_schema.table_constraints tc
+             WHERE tc.table_schema = $1
+               AND tc.table_name = $2
+               AND tc.constraint_name = i.indexname
+           )
+         ORDER BY i.indexname, a.attnum`,
+        [schema, tableName],
+      );
+
+      const indexesMap = new Map<
+        string,
+        {
+          columns: string[];
+          name: string;
+          unique: boolean;
+        }
+      >();
+      for (const idxRow of indexResult.rows) {
+        // Skip rows where attname is null (system columns or invalid attnum)
+        if (!idxRow.attname) {
+          continue;
+        }
+        const existing = indexesMap.get(idxRow.indexname);
+        if (existing) {
+          existing.columns.push(idxRow.attname);
+        } else {
+          indexesMap.set(idxRow.indexname, {
+            columns: [idxRow.attname],
+            name: idxRow.indexname,
+            unique: idxRow.indisunique,
+          });
+        }
+      }
+      const indexes: readonly SqlIndexIR[] = Array.from(indexesMap.values()).map((idx) => ({
+        columns: Object.freeze([...idx.columns]) as readonly string[],
+        name: idx.name,
+        unique: idx.unique,
+      }));
+
+      tables[tableName] = {
+        name: tableName,
+        columns,
+        ...(primaryKey ? { primaryKey } : {}),
+        foreignKeys,
+        uniques,
+        indexes,
+      };
+    }
+
+    // Query extensions
+    const extensionsResult = await driver.query<{
+      extname: string;
+    }>(
+      `SELECT extname
+       FROM pg_extension
+       ORDER BY extname`,
+      [],
+    );
+
+    const extensions = extensionsResult.rows.map((row) => row.extname);
+
+    // Build annotations with Postgres-specific metadata
+    const annotations = {
+      pg: {
+        schema,
+        version: await this.getPostgresVersion(driver),
+      },
+    };
+
+    return {
+      tables,
+      extensions,
+      annotations,
+    };
+  }
+
+  /**
+   * Gets the Postgres version from the database.
+   */
+  private async getPostgresVersion(
+    driver: ControlDriverInstance<'sql', 'postgres'>,
+  ): Promise<string> {
+    const result = await driver.query<{ version: string }>('SELECT version() AS version', []);
+    const versionString = result.rows[0]?.version ?? '';
+    // Extract version number from "PostgreSQL 15.1 ..." format
+    const match = versionString.match(/PostgreSQL (\d+\.\d+)/);
+    return match?.[1] ?? 'unknown';
+  }
+}

package/src/core/descriptor-meta.ts

@@ -0,0 +1,41 @@
+export const 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' },
+    ],
+  },
+} as const;

package/src/core/types.ts

@@ -0,0 +1,53 @@
+import type {
+  SqlContract,
+  SqlStorage,
+  StorageColumn,
+  StorageTable,
+} from '@prisma-next/sql-contract/types';
+import type {
+  BinaryExpr,
+  ColumnRef,
+  DeleteAst,
+  Direction,
+  InsertAst,
+  JoinAst,
+  LiteralExpr,
+  LoweredStatement,
+  OperationExpr,
+  ParamRef,
+  QueryAst,
+  SelectAst,
+  UpdateAst,
+} from '@prisma-next/sql-relational-core/ast';
+
+export interface PostgresAdapterOptions {
+  readonly profileId?: string;
+}
+
+export type PostgresContract = SqlContract<SqlStorage> & { readonly target: 'postgres' };
+
+export type Expr = ColumnRef | ParamRef;
+
+export interface OrderClause {
+  readonly expr: ColumnRef;
+  readonly dir: Direction;
+}
+
+export type PostgresLoweredStatement = LoweredStatement;
+
+export type {
+  BinaryExpr,
+  ColumnRef,
+  DeleteAst,
+  Direction,
+  InsertAst,
+  JoinAst,
+  LiteralExpr,
+  OperationExpr,
+  ParamRef,
+  QueryAst,
+  SelectAst,
+  StorageColumn,
+  StorageTable,
+  UpdateAst,
+};

package/src/exports/adapter.ts

@@ -0,0 +1 @@
+export { createPostgresAdapter } from '../core/adapter';

package/src/exports/codec-types.ts

@@ -0,0 +1,11 @@
+/**
+ * Codec type definitions for Postgres adapter.
+ *
+ * This file exports type-only definitions for codec input/output types.
+ * These types are imported by contract.d.ts files for compile-time type inference.
+ *
+ * Runtime codec implementations are provided by the adapter's codec registry.
+ */
+
+export type { CodecTypes } from '../core/codecs';
+export { dataTypes } from '../core/codecs';

package/src/exports/column-types.ts

@@ -0,0 +1,53 @@
+/**
+ * Column type descriptors for Postgres adapter.
+ *
+ * These descriptors provide both codecId and nativeType for use in contract authoring.
+ * They are derived from the same source of truth as codec definitions and manifests.
+ */
+
+import type { ColumnTypeDescriptor } from '@prisma-next/contract-authoring';
+
+export const textColumn: ColumnTypeDescriptor = {
+  codecId: 'pg/text@1',
+  nativeType: 'text',
+} as const;
+
+export const int4Column: ColumnTypeDescriptor = {
+  codecId: 'pg/int4@1',
+  nativeType: 'int4',
+} as const;
+
+export const int2Column: ColumnTypeDescriptor = {
+  codecId: 'pg/int2@1',
+  nativeType: 'int2',
+} as const;
+
+export const int8Column: ColumnTypeDescriptor = {
+  codecId: 'pg/int8@1',
+  nativeType: 'int8',
+} as const;
+
+export const float4Column: ColumnTypeDescriptor = {
+  codecId: 'pg/float4@1',
+  nativeType: 'float4',
+} as const;
+
+export const float8Column: ColumnTypeDescriptor = {
+  codecId: 'pg/float8@1',
+  nativeType: 'float8',
+} as const;
+
+export const timestampColumn: ColumnTypeDescriptor = {
+  codecId: 'pg/timestamp@1',
+  nativeType: 'timestamp',
+} as const;
+
+export const timestamptzColumn: ColumnTypeDescriptor = {
+  codecId: 'pg/timestamptz@1',
+  nativeType: 'timestamptz',
+} as const;
+
+export const boolColumn: ColumnTypeDescriptor = {
+  codecId: 'pg/bool@1',
+  nativeType: 'bool',
+} as const;

package/src/exports/control.ts

@@ -0,0 +1,20 @@
+import type { ControlAdapterDescriptor } from '@prisma-next/core-control-plane/types';
+import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter';
+import { PostgresControlAdapter } from '../core/control-adapter';
+import { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';
+
+/**
+ * Postgres adapter descriptor for CLI config.
+ */
+const postgresAdapterDescriptor: ControlAdapterDescriptor<
+  'sql',
+  'postgres',
+  SqlControlAdapter<'postgres'>
+> = {
+  ...postgresAdapterDescriptorMeta,
+  create(): SqlControlAdapter<'postgres'> {
+    return new PostgresControlAdapter();
+  },
+};
+
+export default postgresAdapterDescriptor;

package/src/exports/runtime.ts

@@ -0,0 +1,32 @@
+import type {
+  RuntimeAdapterDescriptor,
+  RuntimeAdapterInstance,
+} from '@prisma-next/core-execution-plane/types';
+import type { Adapter, QueryAst } from '@prisma-next/sql-relational-core/ast';
+import { createPostgresAdapter } from '../core/adapter';
+import { postgresAdapterDescriptorMeta } from '../core/descriptor-meta';
+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> {}
+
+/**
+ * Postgres adapter descriptor for runtime plane.
+ */
+const postgresRuntimeAdapterDescriptor: RuntimeAdapterDescriptor<
+  'sql',
+  'postgres',
+  SqlRuntimeAdapter
+> = {
+  ...postgresAdapterDescriptorMeta,
+  create(): SqlRuntimeAdapter {
+    return createPostgresAdapter();
+  },
+};
+
+export default postgresRuntimeAdapterDescriptor;

package/src/exports/types.ts

@@ -0,0 +1,14 @@
+export type {
+  BinaryExpr,
+  ColumnRef,
+  Direction,
+  Expr,
+  OrderClause,
+  ParamRef,
+  PostgresAdapterOptions,
+  PostgresContract,
+  PostgresLoweredStatement,
+  SelectAst,
+  StorageColumn,
+  StorageTable,
+} from '../core/types';

package/dist/exports/chunk-B5SU5BVC.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/exports/chunk-CPAKRHXM.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":[]}