@prisma-next/adapter-postgres 0.0.1

package/README.md

@@ -0,0 +1,259 @@
+# @prisma-next/adapter-postgres
+
+PostgreSQL adapter for Prisma Next.
+
+## Package Classification
+
+- **Domain**: targets
+- **Layer**: adapters
+- **Plane**: multi-plane (shared, migration, runtime)
+
+## Overview
+
+The PostgreSQL adapter implements the adapter SPI for PostgreSQL databases. It provides SQL lowering, capability discovery, codec definitions, and error mapping for PostgreSQL-specific behavior.
+
+This package is an extension pack that extends Prisma Next with PostgreSQL-specific capabilities. It includes a manifest declaring its capabilities and codec types, and provides the adapter implementation that lowers SQL ASTs to PostgreSQL dialect SQL.
+
+## Purpose
+
+Provide PostgreSQL-specific adapter implementation, codecs, and capabilities. Enable PostgreSQL dialect support in Prisma Next through the adapter SPI.
+
+## Responsibilities
+
+- **Adapter Implementation**: Implement `Adapter` SPI for PostgreSQL
+  - Lower SQL ASTs to PostgreSQL dialect SQL
+  - Render `includeMany` as `LEFT JOIN LATERAL` with `json_agg` for nested array includes
+  - Advertise PostgreSQL capabilities (`lateral`, `jsonAgg`)
+  - Normalize PostgreSQL EXPLAIN output
+  - Map PostgreSQL errors to `RuntimeError` envelope
+- **Codec Definitions**: Define PostgreSQL codecs for type conversion
+  - Wire format to JavaScript type decoding
+  - JavaScript type to wire format encoding
+- **Codec Types**: Export TypeScript types for PostgreSQL codecs
+- **Extension Pack**: Provide manifest declaring capabilities and codec types
+
+**Non-goals:**
+- Transport/pooling management (drivers)
+- Query compilation (sql-query)
+- Runtime execution (runtime)
+
+## Architecture
+
+This package spans multiple planes:
+
+- **Shared plane** (`src/core/**`): Core adapter implementation, codecs, and types that can be imported by both migration and runtime planes
+- **Migration plane** (`src/exports/cli.ts`): CLI entry point that exports `AdapterDescriptor` for config files
+- **Runtime plane** (`src/exports/runtime.ts`): Runtime entry point for DB-connected commands (future)
+
+```mermaid
+flowchart TD
+    subgraph "Runtime"
+        RT[Runtime]
+        PLAN[Plan]
+    end
+
+    subgraph "Postgres Adapter"
+        ADAPTER[Adapter]
+        LOWERER[Lowerer]
+        CODECS[Codecs]
+        CAPS[Capabilities]
+    end
+
+    subgraph "Postgres Driver"
+        DRIVER[Driver]
+        PG[(PostgreSQL)]
+    end
+
+    subgraph "Extension Pack"
+        MANIFEST[Manifest]
+        CODECTYPES[Codec Types]
+    end
+
+    RT --> PLAN
+    PLAN --> ADAPTER
+    ADAPTER --> LOWERER
+    ADAPTER --> CODECS
+    ADAPTER --> CAPS
+    ADAPTER --> DRIVER
+    DRIVER --> PG
+    MANIFEST --> RT
+    CODECTYPES --> RT
+    CODECS --> CODECTYPES
+```
+
+## Components
+
+### Core (`src/core/`)
+
+**Adapter (`adapter.ts`)**
+- Main adapter implementation
+- Lowers SQL ASTs to PostgreSQL SQL
+- Renders joins (INNER, LEFT, RIGHT, FULL) with ON conditions
+- Renders `includeMany` as `LEFT JOIN LATERAL` with `json_agg` for nested array includes
+- Renders DML operations (INSERT, UPDATE, DELETE) with RETURNING clauses
+- Advertises PostgreSQL capabilities (`lateral`, `jsonAgg`, `returning`)
+- Maps PostgreSQL errors to `RuntimeError`
+
+**Codecs (`codecs.ts`)**
+- PostgreSQL codec definitions
+- Type conversion between wire format and JavaScript
+- Supports PostgreSQL types: `int2`, `int4`, `int8`, `float4`, `float8`, `text`, `timestamp`, `timestamptz`, `bool`
+
+**Types (`types.ts`)**
+- PostgreSQL-specific types and utilities
+- Re-exports SQL contract types
+
+### Exports (`src/exports/`)
+
+**CLI Entry Point (`cli.ts`)**
+- Exports `AdapterDescriptor` for CLI config
+- Loads adapter manifest from `packs/manifest.json`
+- Used by `prisma-next.config.ts` to declare the adapter
+
+**Runtime Entry Point (`runtime.ts`)**
+- Placeholder for future DB-connected commands
+- Will export runtime factory functions
+
+**Adapter Export (`adapter.ts`)**
+- Re-exports `createPostgresAdapter` from core
+
+**Codec Types Export (`codec-types.ts`)**
+- Exports TypeScript type definitions for PostgreSQL codecs
+- Used in `contract.d.ts` generation
+
+**Types Export (`types.ts`)**
+- Re-exports PostgreSQL-specific types
+
+### Manifest (`packs/manifest.json`)
+
+- Extension pack manifest
+- Declares capabilities and codec types import
+- Provides canonical scalar map for type canonicalization
+
+## Dependencies
+
+- **`@prisma-next/sql-contract`**: SQL contract types
+- **`@prisma-next/sql-relational-core`**: SQL AST types and codec registry
+- **`@prisma-next/cli`**: CLI config types and extension pack manifest types
+
+## Related Subsystems
+
+- **[Adapters & Targets](../../docs/architecture%20docs/subsystems/5.%20Adapters%20&%20Targets.md)**: Detailed adapter specification
+- **[Ecosystem Extensions & Packs](../../docs/architecture%20docs/subsystems/6.%20Ecosystem%20Extensions%20&%20Packs.md)**: Extension pack model
+
+## Related ADRs
+
+- [ADR 005 - Thin Core Fat Targets](../../docs/architecture%20docs/adrs/ADR%20005%20-%20Thin%20Core%20Fat%20Targets.md)
+- [ADR 016 - Adapter SPI for Lowering](../../docs/architecture%20docs/adrs/ADR%20016%20-%20Adapter%20SPI%20for%20Lowering.md)
+- [ADR 030 - Result decoding & codecs registry](../../docs/architecture%20docs/adrs/ADR%20030%20-%20Result%20decoding%20&%20codecs%20registry.md)
+- [ADR 065 - Adapter capability schema & negotiation v1](../../docs/architecture%20docs/adrs/ADR%20065%20-%20Adapter%20capability%20schema%20&%20negotiation%20v1.md)
+- [ADR 068 - Error mapping to RuntimeError](../../docs/architecture%20docs/adrs/ADR%20068%20-%20Error%20mapping%20to%20RuntimeError.md)
+- [ADR 112 - Target Extension Packs](../../docs/architecture%20docs/adrs/ADR%20112%20-%20Target%20Extension%20Packs.md)
+- [ADR 114 - Extension codecs & branded types](../../docs/architecture%20docs/adrs/ADR%20114%20-%20Extension%20codecs%20&%20branded%20types.md)
+
+## Usage
+
+### Runtime
+
+```typescript
+import { createPostgresAdapter } from '@prisma-next/adapter-postgres/adapter';
+import { createRuntime } from '@prisma-next/sql-runtime';
+
+const runtime = createRuntime({
+  contract,
+  adapter: createPostgresAdapter(),
+  driver: postgresDriver,
+});
+```
+
+### CLI Config
+
+```typescript
+import postgresAdapter from '@prisma-next/adapter-postgres/control';
+
+export default defineConfig({
+  family: sql,
+  target: postgres,
+  adapter: postgresAdapter,
+  extensions: [],
+});
+```
+
+## Capabilities
+
+The adapter declares the following PostgreSQL capabilities:
+
+- **`orderBy: true`** - Supports ORDER BY clauses
+- **`limit: true`** - Supports LIMIT clauses
+- **`lateral: true`** - Supports LATERAL joins for `includeMany` nested array includes
+- **`jsonAgg: true`** - Supports JSON aggregation functions (`json_agg`) for `includeMany`
+- **`returning: true`** - Supports RETURNING clauses for DML operations (INSERT, UPDATE, DELETE)
+
+**Important**: Capabilities must be declared in **both** places:
+
+1. **`packs/manifest.json`**: Capabilities are read by the CLI during emission and included in the contract
+2. **`src/core/adapter.ts`**: The `defaultCapabilities` constant is used at runtime via `adapter.profile.capabilities`
+
+The capabilities in the manifest must match the capabilities in code. If they don't match, the contract won't include the capabilities, causing runtime capability checks to fail.
+
+See `.cursor/rules/adapter-capability-declaration.mdc` for detailed guidelines.
+
+## includeMany Support
+
+The adapter supports `includeMany` for nested array includes using PostgreSQL's `LATERAL` joins and `json_agg`:
+
+**Lowering Strategy:**
+- Renders `includeMany` as `LEFT JOIN LATERAL` with a subquery that uses `json_agg(json_build_object(...))` to aggregate child rows into a JSON array
+- The ON condition from the include is moved into the WHERE clause of the lateral subquery
+- When both `ORDER BY` and `LIMIT` are present, wraps the query in an inner SELECT that projects individual columns with aliases, then uses `json_agg(row_to_json(sub.*))` on the result
+- Uses different aliases for the table (`{alias}_lateral`) and column (`{alias}`) to avoid ambiguity
+
+**Capabilities Required:**
+- `lateral: true` - Enables LATERAL join support
+- `jsonAgg: true` - Enables `json_agg` function support
+
+**Example SQL Output:**
+```sql
+SELECT "user"."id" AS "id", "posts_lateral"."posts" AS "posts"
+FROM "user"
+LEFT JOIN LATERAL (
+  SELECT json_agg(json_build_object('id', "post"."id", 'title', "post"."title")) AS "posts"
+  FROM "post"
+  WHERE "user"."id" = "post"."userId"
+) AS "posts_lateral" ON true
+```
+
+## DML Operations with RETURNING
+
+The adapter supports RETURNING clauses for DML operations (INSERT, UPDATE, DELETE), allowing you to return affected rows:
+
+**Lowering Strategy:**
+- Renders `RETURNING` clause after INSERT, UPDATE, or DELETE statements
+- Returns specified columns from affected rows
+- Supports returning multiple columns
+
+**Capability Required:**
+- `returning: true` - Enables RETURNING clause support
+
+**Example SQL Output:**
+```sql
+-- INSERT with RETURNING
+INSERT INTO "user" ("email", "createdAt") VALUES ($1, $2) RETURNING "user"."id", "user"."email"
+
+-- UPDATE with RETURNING
+UPDATE "user" SET "email" = $1 WHERE "user"."id" = $2 RETURNING "user"."id", "user"."email"
+
+-- DELETE with RETURNING
+DELETE FROM "user" WHERE "user"."id" = $1 RETURNING "user"."id", "user"."email"
+```
+
+**Note:** MySQL does not support RETURNING clauses. A future MySQL adapter would declare `returning: false` and either reject plans with RETURNING or provide an alternative implementation.
+
+## Exports
+
+- `./adapter`: Adapter implementation (`createPostgresAdapter`)
+- `./codec-types`: PostgreSQL codec types (`CodecTypes`, `dataTypes`)
+- `./types`: PostgreSQL-specific types
+- `./cli`: CLI entry point (`AdapterDescriptor`)
+- `./runtime`: Runtime entry point (placeholder for future)
+

package/dist/exports/adapter.d.ts

@@ -0,0 +1,19 @@
+import { Adapter, QueryAst, AdapterProfile, LowererContext } from '@prisma-next/sql-relational-core/ast';
+import { PostgresAdapterOptions, PostgresContract, PostgresLoweredStatement } from './types.js';
+import '@prisma-next/sql-contract/types';
+
+declare class PostgresAdapterImpl implements Adapter<QueryAst, PostgresContract, PostgresLoweredStatement> {
+    readonly profile: AdapterProfile<'postgres'>;
+    private readonly codecRegistry;
+    constructor(options?: PostgresAdapterOptions);
+    lower(ast: QueryAst, context: LowererContext<PostgresContract>): Readonly<{
+        profileId: string;
+        body: Readonly<{
+            sql: string;
+            params: unknown[];
+        }>;
+    }>;
+}
+declare function createPostgresAdapter(options?: PostgresAdapterOptions): Readonly<PostgresAdapterImpl>;
+
+export { createPostgresAdapter };

package/dist/exports/adapter.js

@@ -0,0 +1,8 @@
+import {
+  createPostgresAdapter
+} from "./chunk-NOYZK3LL.js";
+import "./chunk-CPAKRHXM.js";
+export {
+  createPostgresAdapter
+};
+//# sourceMappingURL=adapter.js.map

package/dist/exports/adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/exports/chunk-CPAKRHXM.js

@@ -0,0 +1,162 @@
+// 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-CPAKRHXM.js.map

package/dist/exports/chunk-CPAKRHXM.js.map

@@ -0,0 +1 @@
+{"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":[]}