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

package/dist/exports/types.d.ts

@@ -1,19 +1,2 @@
-import { SqlContract, SqlStorage } from '@prisma-next/sql-contract/types';
-export { StorageColumn, StorageTable } from '@prisma-next/sql-contract/types';
-import { LoweredStatement, ColumnRef, ParamRef, Direction } from '@prisma-next/sql-relational-core/ast';
-export { BinaryExpr, ColumnRef, Direction, ParamRef, SelectAst } from '@prisma-next/sql-relational-core/ast';
-
-interface PostgresAdapterOptions {
-    readonly profileId?: string;
-}
-type PostgresContract = SqlContract<SqlStorage> & {
-    readonly target: 'postgres';
-};
-type Expr = ColumnRef | ParamRef;
-interface OrderClause {
-    readonly expr: ColumnRef;
-    readonly dir: Direction;
-}
-type PostgresLoweredStatement = LoweredStatement;
-
-export type { Expr, OrderClause, PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement };
+export type { BinaryExpr, ColumnRef, Direction, Expr, OrderClause, ParamRef, PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement, SelectAst, StorageColumn, StorageTable, } from '../core/types';
+//# sourceMappingURL=types.d.ts.map

package/dist/exports/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/exports/types.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,UAAU,EACV,SAAS,EACT,SAAS,EACT,IAAI,EACJ,WAAW,EACX,QAAQ,EACR,sBAAsB,EACtB,gBAAgB,EAChB,wBAAwB,EACxB,SAAS,EACT,aAAa,EACb,YAAY,GACb,MAAM,eAAe,CAAC"}

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "@prisma-next/adapter-postgres",
-  "version": "0.3.0-dev.4",
+  "version": "0.3.0-dev.6",
   "type": "module",
   "sideEffects": false,
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "dependencies": {
     "arktype": "^2.0.0",
-    "@prisma-next/cli": "0.3.0-dev.4",
-    "@prisma-next/contract": "0.3.0-dev.4",
-    "@prisma-next/contract-authoring": "0.3.0-dev.4",
-    "@prisma-next/core-control-plane": "0.3.0-dev.4",
-    "@prisma-next/core-execution-plane": "0.3.0-dev.4",
-    "@prisma-next/family-sql": "0.3.0-dev.4",
-    "@prisma-next/sql-contract-ts": "0.3.0-dev.4",
-    "@prisma-next/sql-contract": "0.3.0-dev.4",
-    "@prisma-next/sql-operations": "0.3.0-dev.4",
-    "@prisma-next/sql-relational-core": "0.3.0-dev.4",
-    "@prisma-next/sql-schema-ir": "0.3.0-dev.4"
+    "@prisma-next/contract": "0.3.0-dev.6",
+    "@prisma-next/contract-authoring": "0.3.0-dev.6",
+    "@prisma-next/cli": "0.3.0-dev.6",
+    "@prisma-next/core-control-plane": "0.3.0-dev.6",
+    "@prisma-next/family-sql": "0.3.0-dev.6",
+    "@prisma-next/sql-contract-ts": "0.3.0-dev.6",
+    "@prisma-next/sql-contract": "0.3.0-dev.6",
+    "@prisma-next/sql-operations": "0.3.0-dev.6",
+    "@prisma-next/sql-relational-core": "0.3.0-dev.6",
+    "@prisma-next/sql-schema-ir": "0.3.0-dev.6",
+    "@prisma-next/core-execution-plane": "0.3.0-dev.6"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "4.0.16",
@@ -55,7 +56,7 @@
     }
   },
   "scripts": {
-    "build": "tsup --config tsup.config.ts",
+    "build": "tsup --config tsup.config.ts && tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "typecheck": "tsc --project tsconfig.json --noEmit",

package/src/core/adapter.ts

@@ -0,0 +1,429 @@
+import type {
+  Adapter,
+  AdapterProfile,
+  BinaryExpr,
+  ColumnRef,
+  DeleteAst,
+  ExistsExpr,
+  IncludeRef,
+  InsertAst,
+  JoinAst,
+  LiteralExpr,
+  LowererContext,
+  OperationExpr,
+  ParamRef,
+  QueryAst,
+  SelectAst,
+  UpdateAst,
+} from '@prisma-next/sql-relational-core/ast';
+import { createCodecRegistry, isOperationExpr } from '@prisma-next/sql-relational-core/ast';
+import { codecDefinitions } from './codecs';
+import type { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types';
+
+const VECTOR_CODEC_ID = 'pg/vector@1' as const;
+
+const defaultCapabilities = Object.freeze({
+  postgres: {
+    orderBy: true,
+    limit: true,
+    lateral: true,
+    jsonAgg: true,
+    returning: true,
+  },
+});
+
+class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, PostgresLoweredStatement> {
+  // These fields make the adapter instance structurally compatible with
+  // RuntimeAdapterInstance<'sql', 'postgres'> without introducing a runtime-plane dependency.
+  readonly familyId = 'sql' as const;
+  readonly targetId = 'postgres' as const;
+
+  readonly profile: AdapterProfile<'postgres'>;
+  private readonly codecRegistry = (() => {
+    const registry = createCodecRegistry();
+    for (const definition of Object.values(codecDefinitions)) {
+      registry.register(definition.codec);
+    }
+    return registry;
+  })();
+
+  constructor(options?: PostgresAdapterOptions) {
+    this.profile = Object.freeze({
+      id: options?.profileId ?? 'postgres/default@1',
+      target: 'postgres',
+      capabilities: defaultCapabilities,
+      codecs: () => this.codecRegistry,
+    });
+  }
+
+  lower(ast: QueryAst, context: LowererContext<PostgresContract>) {
+    let sql: string;
+    const params = context.params ? [...context.params] : [];
+
+    if (ast.kind === 'select') {
+      sql = renderSelect(ast, context.contract);
+    } else if (ast.kind === 'insert') {
+      sql = renderInsert(ast, context.contract);
+    } else if (ast.kind === 'update') {
+      sql = renderUpdate(ast, context.contract);
+    } else if (ast.kind === 'delete') {
+      sql = renderDelete(ast, context.contract);
+    } else {
+      throw new Error(`Unsupported AST kind: ${(ast as { kind: string }).kind}`);
+    }
+
+    return Object.freeze({
+      profileId: this.profile.id,
+      body: Object.freeze({ sql, params }),
+    });
+  }
+}
+
+function renderSelect(ast: SelectAst, contract?: PostgresContract): string {
+  const selectClause = `SELECT ${renderProjection(ast, contract)}`;
+  const fromClause = `FROM ${quoteIdentifier(ast.from.name)}`;
+
+  const joinsClause = ast.joins?.length
+    ? ast.joins.map((join) => renderJoin(join, contract)).join(' ')
+    : '';
+  const includesClause = ast.includes?.length
+    ? ast.includes.map((include) => renderInclude(include, contract)).join(' ')
+    : '';
+
+  const whereClause = ast.where ? ` WHERE ${renderWhere(ast.where, contract)}` : '';
+  const orderClause = ast.orderBy?.length
+    ? ` ORDER BY ${ast.orderBy
+        .map((order) => {
+          const expr = renderExpr(order.expr as ColumnRef | OperationExpr, contract);
+          return `${expr} ${order.dir.toUpperCase()}`;
+        })
+        .join(', ')}`
+    : '';
+  const limitClause = typeof ast.limit === 'number' ? ` LIMIT ${ast.limit}` : '';
+
+  const clauses = [joinsClause, includesClause].filter(Boolean).join(' ');
+  return `${selectClause} ${fromClause}${clauses ? ` ${clauses}` : ''}${whereClause}${orderClause}${limitClause}`.trim();
+}
+
+function renderProjection(ast: SelectAst, contract?: PostgresContract): string {
+  return ast.project
+    .map((item) => {
+      const expr = item.expr as ColumnRef | IncludeRef | OperationExpr | LiteralExpr;
+      if (expr.kind === 'includeRef') {
+        // For include references, select the column from the LATERAL join alias
+        // The LATERAL subquery returns a single column (the JSON array) with the alias
+        // The table is aliased as {alias}_lateral, and the column inside is aliased as the include alias
+        // We select it using table_alias.column_alias
+        const tableAlias = `${expr.alias}_lateral`;
+        return `${quoteIdentifier(tableAlias)}.${quoteIdentifier(expr.alias)} AS ${quoteIdentifier(item.alias)}`;
+      }
+      if (expr.kind === 'operation') {
+        const operation = renderOperation(expr, contract);
+        const alias = quoteIdentifier(item.alias);
+        return `${operation} AS ${alias}`;
+      }
+      if (expr.kind === 'literal') {
+        const literal = renderLiteral(expr);
+        const alias = quoteIdentifier(item.alias);
+        return `${literal} AS ${alias}`;
+      }
+      const column = renderColumn(expr as ColumnRef);
+      const alias = quoteIdentifier(item.alias);
+      return `${column} AS ${alias}`;
+    })
+    .join(', ');
+}
+
+function renderWhere(expr: BinaryExpr | ExistsExpr, contract?: PostgresContract): string {
+  if (expr.kind === 'exists') {
+    const notKeyword = expr.not ? 'NOT ' : '';
+    const subquery = renderSelect(expr.subquery, contract);
+    return `${notKeyword}EXISTS (${subquery})`;
+  }
+  return renderBinary(expr, contract);
+}
+
+function renderBinary(expr: BinaryExpr, contract?: PostgresContract): string {
+  const leftExpr = expr.left as ColumnRef | OperationExpr;
+  const left = renderExpr(leftExpr, contract);
+  // Handle both ParamRef and ColumnRef on the right side
+  // (ColumnRef can appear in EXISTS subqueries for correlation)
+  const rightExpr = expr.right as ParamRef | ColumnRef;
+  const right =
+    rightExpr.kind === 'col'
+      ? renderColumn(rightExpr)
+      : renderParam(rightExpr as ParamRef, contract);
+  // Only wrap in parentheses if it's an operation expression
+  const leftRendered = isOperationExpr(leftExpr) ? `(${left})` : left;
+
+  // Map operators to SQL symbols
+  const operatorMap: Record<BinaryExpr['op'], string> = {
+    eq: '=',
+    neq: '!=',
+    gt: '>',
+    lt: '<',
+    gte: '>=',
+    lte: '<=',
+  };
+
+  return `${leftRendered} ${operatorMap[expr.op]} ${right}`;
+}
+
+function renderColumn(ref: ColumnRef): string {
+  return `${quoteIdentifier(ref.table)}.${quoteIdentifier(ref.column)}`;
+}
+
+function renderExpr(expr: ColumnRef | OperationExpr, contract?: PostgresContract): string {
+  if (isOperationExpr(expr)) {
+    return renderOperation(expr, contract);
+  }
+  return renderColumn(expr);
+}
+
+function renderParam(
+  ref: ParamRef,
+  contract?: PostgresContract,
+  tableName?: string,
+  columnName?: string,
+): string {
+  // Cast vector parameters to vector type for PostgreSQL
+  if (contract && tableName && columnName) {
+    const tableMeta = contract.storage.tables[tableName];
+    const columnMeta = tableMeta?.columns[columnName];
+    if (columnMeta?.codecId === VECTOR_CODEC_ID) {
+      return `$${ref.index}::vector`;
+    }
+  }
+  return `$${ref.index}`;
+}
+
+function renderLiteral(expr: LiteralExpr): string {
+  if (typeof expr.value === 'string') {
+    return `'${expr.value.replace(/'/g, "''")}'`;
+  }
+  if (typeof expr.value === 'number' || typeof expr.value === 'boolean') {
+    return String(expr.value);
+  }
+  if (expr.value === null) {
+    return 'NULL';
+  }
+  if (Array.isArray(expr.value)) {
+    return `ARRAY[${expr.value.map((v: unknown) => renderLiteral({ kind: 'literal', value: v })).join(', ')}]`;
+  }
+  return JSON.stringify(expr.value);
+}
+
+function renderOperation(expr: OperationExpr, contract?: PostgresContract): string {
+  const self = renderExpr(expr.self, contract);
+  // For vector operations, cast param arguments to vector type
+  const isVectorOperation = expr.forTypeId === VECTOR_CODEC_ID;
+  const args = expr.args.map((arg: ColumnRef | ParamRef | LiteralExpr | OperationExpr) => {
+    if (arg.kind === 'col') {
+      return renderColumn(arg);
+    }
+    if (arg.kind === 'param') {
+      // Cast vector operation parameters to vector type
+      return isVectorOperation ? `$${arg.index}::vector` : renderParam(arg, contract);
+    }
+    if (arg.kind === 'literal') {
+      return renderLiteral(arg);
+    }
+    if (arg.kind === 'operation') {
+      return renderOperation(arg, contract);
+    }
+    const _exhaustive: never = arg;
+    throw new Error(`Unsupported argument kind: ${(_exhaustive as { kind: string }).kind}`);
+  });
+
+  let result = expr.lowering.template;
+  result = result.replace(/\$\{self\}/g, self);
+  for (let i = 0; i < args.length; i++) {
+    result = result.replace(new RegExp(`\\$\\{arg${i}\\}`, 'g'), args[i] ?? '');
+  }
+
+  if (expr.lowering.strategy === 'function') {
+    return result;
+  }
+
+  return result;
+}
+
+function renderJoin(join: JoinAst, _contract?: PostgresContract): string {
+  const joinType = join.joinType.toUpperCase();
+  const table = quoteIdentifier(join.table.name);
+  const onClause = renderJoinOn(join.on);
+  return `${joinType} JOIN ${table} ON ${onClause}`;
+}
+
+function renderJoinOn(on: JoinAst['on']): string {
+  if (on.kind === 'eqCol') {
+    const left = renderColumn(on.left);
+    const right = renderColumn(on.right);
+    return `${left} = ${right}`;
+  }
+  throw new Error(`Unsupported join ON expression kind: ${on.kind}`);
+}
+
+function renderInclude(
+  include: NonNullable<SelectAst['includes']>[number],
+  contract?: PostgresContract,
+): string {
+  const alias = include.alias;
+
+  // Build the lateral subquery
+  const childProjection = include.child.project
+    .map((item: { alias: string; expr: ColumnRef | OperationExpr }) => {
+      const expr = renderExpr(item.expr, contract);
+      return `'${item.alias}', ${expr}`;
+    })
+    .join(', ');
+
+  const jsonBuildObject = `json_build_object(${childProjection})`;
+
+  // Build the ON condition from the include's ON clause - this goes in the WHERE clause
+  const onCondition = renderJoinOn(include.child.on);
+
+  // Build WHERE clause: combine ON condition with any additional WHERE clauses
+  let whereClause = ` WHERE ${onCondition}`;
+  if (include.child.where) {
+    whereClause += ` AND ${renderWhere(include.child.where, contract)}`;
+  }
+
+  // Add ORDER BY if present - it goes inside json_agg() call
+  const childOrderBy = include.child.orderBy?.length
+    ? ` ORDER BY ${include.child.orderBy
+        .map(
+          (order: { expr: ColumnRef | OperationExpr; dir: string }) =>
+            `${renderExpr(order.expr, contract)} ${order.dir.toUpperCase()}`,
+        )
+        .join(', ')}`
+    : '';
+
+  // Add LIMIT if present
+  const childLimit = typeof include.child.limit === 'number' ? ` LIMIT ${include.child.limit}` : '';
+
+  // Build the lateral subquery
+  // When ORDER BY is present without LIMIT, it goes inside json_agg() call: json_agg(expr ORDER BY ...)
+  // When LIMIT is present (with or without ORDER BY), we need to wrap in a subquery
+  const childTable = quoteIdentifier(include.child.table.name);
+  let subquery: string;
+  if (typeof include.child.limit === 'number') {
+    // With LIMIT, we need to wrap in a subquery
+    // Select individual columns in inner query, then aggregate
+    // Create a map of column references to their aliases for ORDER BY
+    // Only ColumnRef can be mapped (OperationExpr doesn't have table/column properties)
+    const columnAliasMap = new Map<string, string>();
+    for (const item of include.child.project) {
+      if (item.expr.kind === 'col') {
+        const columnKey = `${item.expr.table}.${item.expr.column}`;
+        columnAliasMap.set(columnKey, item.alias);
+      }
+    }
+
+    const innerColumns = include.child.project
+      .map((item: { alias: string; expr: ColumnRef | OperationExpr }) => {
+        const expr = renderExpr(item.expr, contract);
+        return `${expr} AS ${quoteIdentifier(item.alias)}`;
+      })
+      .join(', ');
+
+    // For ORDER BY, use column aliases if the column is in the SELECT list
+    const childOrderByWithAliases = include.child.orderBy?.length
+      ? ` ORDER BY ${include.child.orderBy
+          .map((order: { expr: ColumnRef | OperationExpr; dir: string }) => {
+            if (order.expr.kind === 'col') {
+              const columnKey = `${order.expr.table}.${order.expr.column}`;
+              const alias = columnAliasMap.get(columnKey);
+              if (alias) {
+                return `${quoteIdentifier(alias)} ${order.dir.toUpperCase()}`;
+              }
+            }
+            return `${renderExpr(order.expr, contract)} ${order.dir.toUpperCase()}`;
+          })
+          .join(', ')}`
+      : '';
+
+    const innerSelect = `SELECT ${innerColumns} FROM ${childTable}${whereClause}${childOrderByWithAliases}${childLimit}`;
+    subquery = `(SELECT json_agg(row_to_json(sub.*)) AS ${quoteIdentifier(alias)} FROM (${innerSelect}) sub)`;
+  } else if (childOrderBy) {
+    // With ORDER BY but no LIMIT, ORDER BY goes inside json_agg()
+    subquery = `(SELECT json_agg(${jsonBuildObject}${childOrderBy}) AS ${quoteIdentifier(alias)} FROM ${childTable}${whereClause})`;
+  } else {
+    // No ORDER BY or LIMIT
+    subquery = `(SELECT json_agg(${jsonBuildObject}) AS ${quoteIdentifier(alias)} FROM ${childTable}${whereClause})`;
+  }
+
+  // Return the LATERAL join with ON true (the condition is in the WHERE clause)
+  // The subquery returns a single column (the JSON array) with the alias
+  // We use a different alias for the table to avoid ambiguity when selecting the column
+  const tableAlias = `${alias}_lateral`;
+  return `LEFT JOIN LATERAL ${subquery} AS ${quoteIdentifier(tableAlias)} ON true`;
+}
+
+function quoteIdentifier(identifier: string): string {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+
+function renderInsert(ast: InsertAst, contract: PostgresContract): string {
+  const table = quoteIdentifier(ast.table.name);
+  const columns = Object.keys(ast.values).map((col) => quoteIdentifier(col));
+  const tableMeta = contract.storage.tables[ast.table.name];
+  const values = Object.entries(ast.values).map(([colName, val]) => {
+    if (val.kind === 'param') {
+      const columnMeta = tableMeta?.columns[colName];
+      const isVector = columnMeta?.codecId === VECTOR_CODEC_ID;
+      return isVector ? `$${val.index}::vector` : `$${val.index}`;
+    }
+    if (val.kind === 'col') {
+      return `${quoteIdentifier(val.table)}.${quoteIdentifier(val.column)}`;
+    }
+    throw new Error(`Unsupported value kind in INSERT: ${(val as { kind: string }).kind}`);
+  });
+
+  const insertClause = `INSERT INTO ${table} (${columns.join(', ')}) VALUES (${values.join(', ')})`;
+  const returningClause = ast.returning?.length
+    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
+    : '';
+
+  return `${insertClause}${returningClause}`;
+}
+
+function renderUpdate(ast: UpdateAst, contract: PostgresContract): string {
+  const table = quoteIdentifier(ast.table.name);
+  const tableMeta = contract.storage.tables[ast.table.name];
+  const setClauses = Object.entries(ast.set).map(([col, val]) => {
+    const column = quoteIdentifier(col);
+    let value: string;
+    if (val.kind === 'param') {
+      const columnMeta = tableMeta?.columns[col];
+      const isVector = columnMeta?.codecId === VECTOR_CODEC_ID;
+      value = isVector ? `$${val.index}::vector` : `$${val.index}`;
+    } else if (val.kind === 'col') {
+      value = `${quoteIdentifier(val.table)}.${quoteIdentifier(val.column)}`;
+    } else {
+      throw new Error(`Unsupported value kind in UPDATE: ${(val as { kind: string }).kind}`);
+    }
+    return `${column} = ${value}`;
+  });
+
+  const whereClause = ` WHERE ${renderBinary(ast.where, contract)}`;
+  const returningClause = ast.returning?.length
+    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
+    : '';
+
+  return `UPDATE ${table} SET ${setClauses.join(', ')}${whereClause}${returningClause}`;
+}
+
+function renderDelete(ast: DeleteAst, contract?: PostgresContract): string {
+  const table = quoteIdentifier(ast.table.name);
+  const whereClause = ` WHERE ${renderBinary(ast.where, contract)}`;
+  const returningClause = ast.returning?.length
+    ? ` RETURNING ${ast.returning.map((col) => `${quoteIdentifier(col.table)}.${quoteIdentifier(col.column)}`).join(', ')}`
+    : '';
+
+  return `DELETE FROM ${table}${whereClause}${returningClause}`;
+}
+
+export function createPostgresAdapter(options?: PostgresAdapterOptions) {
+  return Object.freeze(new PostgresAdapterImpl(options));
+}

package/src/core/codecs.ts

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