@prisma/orm-target-postgres 0.16.0-dev.36

package/dist/control-6WFTtLAM.mjs

@@ -0,0 +1,60 @@
+import { i as postgresDriverDescriptorMeta, r as normalizePgError } from "./normalize-error-CNjgVO71-CLlZ3CuJ.mjs";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { SqlQueryError } from "@prisma/orm-family-sql/errors";
+import { errorRuntime } from "@prisma/orm-framework/errors/execution";
+import { redactDatabaseUrl } from "@prisma/orm-framework/utils/redact-db-url";
+import { Client } from "pg";
+//#region ../../../3-targets/7-drivers/postgres/dist/control.mjs
+var PostgresControlDriver = class {
+	client;
+	familyId = "sql";
+	targetId = "postgres";
+	constructor(client) {
+		this.client = client;
+	}
+	async query(sql, params) {
+		try {
+			return { rows: (await this.client.query(sql, params)).rows };
+		} catch (error) {
+			throw normalizePgError(error);
+		}
+	}
+	async close() {
+		await this.client.end().catch(() => {});
+	}
+};
+/**
+* Postgres driver descriptor for CLI config.
+*/
+const postgresDriverDescriptor = {
+	...postgresDriverDescriptorMeta,
+	async create(url) {
+		const client = new Client({ connectionString: url });
+		client.on("error", () => {});
+		try {
+			await client.connect();
+			return new PostgresControlDriver(client);
+		} catch (error) {
+			const normalized = normalizePgError(error);
+			const redacted = redactDatabaseUrl(url);
+			try {
+				await client.end();
+			} catch {}
+			const codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : void 0;
+			const causeCode = "cause" in normalized && normalized.cause ? normalized.cause.code : void 0;
+			const code = codeFromSqlState ?? causeCode;
+			throw errorRuntime("Database connection failed", {
+				why: normalized.message,
+				fix: "Verify the database URL, ensure the database is reachable, and confirm credentials/permissions",
+				meta: {
+					...ifDefined("code", code),
+					...redacted
+				}
+			});
+		}
+	}
+};
+//#endregion
+export { postgresDriverDescriptor as n, PostgresControlDriver as t };
+
+//# sourceMappingURL=control-6WFTtLAM.mjs.map

package/dist/control-6WFTtLAM.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-6WFTtLAM.mjs","names":[],"sources":["../../../../3-targets/7-drivers/postgres/dist/control.mjs"],"sourcesContent":["import { i as postgresDriverDescriptorMeta, r as normalizePgError } from \"./normalize-error-CNjgVO71.mjs\";\nimport { errorRuntime } from \"@internal/errors/execution\";\nimport { SqlQueryError } from \"@internal/sql-errors\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { redactDatabaseUrl } from \"@internal/utils/redact-db-url\";\nimport { Client } from \"pg\";\n//#region src/exports/control.ts\nvar PostgresControlDriver = class {\n\tclient;\n\tfamilyId = \"sql\";\n\ttargetId = \"postgres\";\n\tconstructor(client) {\n\t\tthis.client = client;\n\t}\n\tasync query(sql, params) {\n\t\ttry {\n\t\t\treturn { rows: (await this.client.query(sql, params)).rows };\n\t\t} catch (error) {\n\t\t\tthrow normalizePgError(error);\n\t\t}\n\t}\n\tasync close() {\n\t\tawait this.client.end().catch(() => {});\n\t}\n};\n/**\n* Postgres driver descriptor for CLI config.\n*/\nconst postgresDriverDescriptor = {\n\t...postgresDriverDescriptorMeta,\n\tasync create(url) {\n\t\tconst client = new Client({ connectionString: url });\n\t\tclient.on(\"error\", () => {});\n\t\ttry {\n\t\t\tawait client.connect();\n\t\t\treturn new PostgresControlDriver(client);\n\t\t} catch (error) {\n\t\t\tconst normalized = normalizePgError(error);\n\t\t\tconst redacted = redactDatabaseUrl(url);\n\t\t\ttry {\n\t\t\t\tawait client.end();\n\t\t\t} catch {}\n\t\t\tconst codeFromSqlState = SqlQueryError.is(normalized) ? normalized.sqlState : void 0;\n\t\t\tconst causeCode = \"cause\" in normalized && normalized.cause ? normalized.cause.code : void 0;\n\t\t\tconst code = codeFromSqlState ?? causeCode;\n\t\t\tthrow errorRuntime(\"Database connection failed\", {\n\t\t\t\twhy: normalized.message,\n\t\t\t\tfix: \"Verify the database URL, ensure the database is reachable, and confirm credentials/permissions\",\n\t\t\t\tmeta: {\n\t\t\t\t\t...ifDefined(\"code\", code),\n\t\t\t\t\t...redacted\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t}\n};\n//#endregion\nexport { PostgresControlDriver, postgresDriverDescriptor as default };\n\n//# sourceMappingURL=control.mjs.map"],"mappings":";;;;;;;AAOA,IAAI,wBAAwB,MAAM;CACjC;CACA,WAAW;CACX,WAAW;CACX,YAAY,QAAQ;EACnB,KAAK,SAAS;CACf;CACA,MAAM,MAAM,KAAK,QAAQ;EACxB,IAAI;GACH,OAAO,EAAE,OAAO,MAAM,KAAK,OAAO,MAAM,KAAK,MAAM,EAAA,CAAG,KAAK;EAC5D,SAAS,OAAO;GACf,MAAM,iBAAiB,KAAK;EAC7B;CACD;CACA,MAAM,QAAQ;EACb,MAAM,KAAK,OAAO,IAAI,CAAC,CAAC,YAAY,CAAC,CAAC;CACvC;AACD;;;;AAIA,MAAM,2BAA2B;CAChC,GAAG;CACH,MAAM,OAAO,KAAK;EACjB,MAAM,SAAS,IAAI,OAAO,EAAE,kBAAkB,IAAI,CAAC;EACnD,OAAO,GAAG,eAAe,CAAC,CAAC;EAC3B,IAAI;GACH,MAAM,OAAO,QAAQ;GACrB,OAAO,IAAI,sBAAsB,MAAM;EACxC,SAAS,OAAO;GACf,MAAM,aAAa,iBAAiB,KAAK;GACzC,MAAM,WAAW,kBAAkB,GAAG;GACtC,IAAI;IACH,MAAM,OAAO,IAAI;GAClB,QAAQ,CAAC;GACT,MAAM,mBAAmB,cAAc,GAAG,UAAU,IAAI,WAAW,WAAW,KAAK;GACnF,MAAM,YAAY,WAAW,cAAc,WAAW,QAAQ,WAAW,MAAM,OAAO,KAAK;GAC3F,MAAM,OAAO,oBAAoB;GACjC,MAAM,aAAa,8BAA8B;IAChD,KAAK,WAAW;IAChB,KAAK;IACL,MAAM;KACL,GAAG,UAAU,QAAQ,IAAI;KACzB,GAAG;IACJ;GACD,CAAC;EACF;CACD;AACD"}

package/dist/control-B-FTbEnE.d.mts

@@ -0,0 +1,22 @@
+import { SqlControlDriverInstance } from "@prisma/orm-family-sql/contract/types";
+import { ControlDriverDescriptor } from "@prisma/orm-framework/components/control";
+import { Client } from "pg";
+//#region ../../../3-targets/7-drivers/postgres/dist/control.d.mts
+//#region src/exports/control.d.ts
+declare class PostgresControlDriver implements SqlControlDriverInstance<'postgres'> {
+  private readonly client;
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  constructor(client: Client);
+  query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<{
+    readonly rows: Row[];
+  }>;
+  close(): Promise<void>;
+}
+/**
+ * Postgres driver descriptor for CLI config.
+ */
+declare const postgresDriverDescriptor: ControlDriverDescriptor<'sql', 'postgres', PostgresControlDriver>;
+//#endregion
+export { postgresDriverDescriptor as n, PostgresControlDriver as t };
+//# sourceMappingURL=control-B-FTbEnE.d.mts.map

package/dist/control-B-FTbEnE.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-B-FTbEnE.d.mts","names":[],"sources":["../../../../3-targets/7-drivers/postgres/dist/control.d.mts"],"mappings":";;;;;cAIc,iCAAiC;mBAC5B;WACR;WACA;EACT,YAAY,QAAQ;EACpB,MAAM,MAAM,yBAAyB,aAAa,8BAA8B;aACrE,MAAM;;EAEjB,SAAS;;;;;cAKG,0BAA0B,2CAA2C"}

package/dist/control-D85zv_aY.d.mts

@@ -0,0 +1,199 @@
+import { n as AnyPostgresCodecDescriptor } from "./codec-descriptor-Bec_zukr-BfvtUqhm.mjs";
+import "./codec-descriptor-Bg-_412t.mjs";
+import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-CyfpHXDr-BqyozkQE.mjs";
+import "./types-xa86TkcV.mjs";
+import { c as PostgresCodecRegistry } from "./types-CkryN1AS-6MNZLjLY.mjs";
+import { h as PostgresDdlNode } from "./nodes-BU-V-aZA-RqwPH68u.mjs";
+import "./ddl-B4Rh8ntj.mjs";
+import { t as parsePostgresDefault } from "./default-normalizer-B36TOul4.mjs";
+import { t as normalizeSchemaNativeType } from "./native-type-normalizer-DqJlOTeX.mjs";
+import { AnyQueryAst, DdlNode, LoweredStatement, LowererContext, MarkerReadResult, SqlExecuteRequest } from "@prisma/orm-family-sql/relational-core/ast";
+import { SqlControlDriverInstance } from "@prisma/orm-family-sql/contract/types";
+import { SqlControlAdapterDescriptor } from "@prisma/orm-family-sql/family/control";
+import { ContractMarkerRecord, LedgerEntryRecord } from "@prisma/orm-framework/contract/types";
+import "@prisma/orm-framework/components/components";
+import { SqlControlAdapter } from "@prisma/orm-family-sql/family/control-adapter";
+//#region ../../../3-targets/6-adapters/postgres/dist/control.d.mts
+//#region src/core/codec-lookup.d.ts
+declare function createPostgresCodecRegistryWithBuiltins(codecDescriptors?: readonly AnyPostgresCodecDescriptor[]): PostgresCodecRegistry;
+/**
+ * Build a coherent PostgreSQL codec registry populated with built-in descriptors only.
+ *
+ * The returned registry supports both ordinary codec materialization and PostgreSQL target behavior. Stack-composed paths build the same combined registry from their complete ordered descriptor contributions.
+ */
+declare function createPostgresBuiltinCodecLookup(): PostgresCodecRegistry;
+//#endregion
+//#region src/core/control-adapter.d.ts
+/**
+ * Postgres control plane adapter for control-plane operations like introspection.
+ * Provides target-specific implementations for control-plane domain actions.
+ */
+declare class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
+  private readonly codecRegistry;
+  readonly familyId: "sql";
+  readonly targetId: "postgres";
+  constructor(codecRegistry: PostgresCodecRegistry);
+  /**
+   * Target-specific normalizer for raw Postgres default expressions.
+   * Used by schema verification to normalize raw defaults before comparison.
+   */
+  readonly normalizeDefault: typeof parsePostgresDefault;
+  /**
+   * Target-specific normalizer for Postgres schema native type names.
+   * Used by schema verification to normalize introspected type names
+   * before comparison with contract native types.
+   */
+  readonly normalizeNativeType: typeof normalizeSchemaNativeType;
+  bootstrapControlTableQueries(): readonly DdlNode[];
+  bootstrapSignMarkerQueries(): readonly DdlNode[];
+  /**
+   * Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
+   *
+   * Delegates to the shared `renderLoweredSql` renderer so the control adapter
+   * emits byte-identical SQL to `PostgresAdapterImpl.lower()` for the same AST
+   * and contract. Used at migration plan/emit time (e.g. by `dataTransform`)
+   * without instantiating the runtime adapter.
+   */
+  lower(ast: AnyQueryAst | PostgresDdlNode, context: LowererContext<unknown>): LoweredStatement;
+  /**
+   * Lower an AST all the way to a driver-ready statement. For DDL nodes,
+   * literal column defaults are formatted as inline SQL with proper quoting and
+   * `::nativeType` cast suffixes. For query ASTs, params are kept as `$N`
+   * placeholders; wire values go in `params`. Does NOT call `this.lower()` —
+   * independent implementation.
+   */
+  lowerToExecuteRequest(ast: AnyQueryAst | PostgresDdlNode, context?: LowererContext<unknown>): Promise<SqlExecuteRequest>;
+  /**
+   * Reads the contract marker from `prisma_contract.marker`. Probes
+   * `information_schema.tables` first so a fresh database (where the
+   * `prisma_contract` schema doesn't yet exist) returns `null` instead of a
+   * "relation does not exist" error — some Postgres wire-protocol clients
+   * (e.g. PGlite's TCP proxy) don't fully recover from extended-protocol
+   * parse errors, so we probe before reading.
+   */
+  readMarker(driver: SqlControlDriverInstance<'postgres'>, space: string): Promise<ContractMarkerRecord | null>;
+  readMarkerDiscriminated(driver: SqlControlDriverInstance<'postgres'>, space: string): Promise<MarkerReadResult>;
+  /**
+   * Reads every row from `prisma_contract.marker` and returns them keyed
+   * by `space`. Mirrors the existence probe in {@link readMarker}: a
+   * fresh database without the `prisma_contract` schema returns an empty
+   * map rather than raising "relation does not exist".
+   */
+  readAllMarkers(driver: SqlControlDriverInstance<'postgres'>): Promise<ReadonlyMap<string, ContractMarkerRecord>>;
+  private readAllMarkersResult;
+  /**
+   * Reads per-migration ledger rows from `prisma_contract.ledger` in apply
+   * order. Probes `information_schema.tables` first so a fresh database
+   * without the ledger table returns `[]` instead of raising "relation does
+   * not exist".
+   */
+  readLedger(driver: SqlControlDriverInstance<'postgres'>, space?: string): Promise<readonly LedgerEntryRecord[]>;
+  private readLedgerResult;
+  /**
+   * Stamps the initial marker row for `space` via the shared contract-free DML
+   * builder, lowered through {@link lower} and executed on the driver. See the
+   * `SqlControlAdapter.initMarker` contract.
+   */
+  insertMarker(driver: SqlControlDriverInstance<'postgres'>, space: string, destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  }): Promise<void>;
+  initMarker(driver: SqlControlDriverInstance<'postgres'>, space: string, destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  }): Promise<void>;
+  /**
+   * Compare-and-swap advance of the marker row for `space`. See the
+   * `SqlControlAdapter.updateMarker` contract.
+   */
+  updateMarker(driver: SqlControlDriverInstance<'postgres'>, space: string, expectedFrom: string, destination: {
+    readonly storageHash: string;
+    readonly profileHash: string;
+    readonly invariants?: readonly string[];
+  }): Promise<boolean>;
+  /**
+   * Appends a ledger entry for `space`. When the edge carries a
+   * destination contract snapshot, the content-addressed
+   * `prisma_contract.contract` store is populated first (keyed by the
+   * destination hash, DO NOTHING on revisit) so a reader never sees a
+   * ledger row whose stored destination contract is missing. See the
+   * `SqlControlAdapter.writeLedgerEntry` contract.
+   */
+  writeLedgerEntry(driver: SqlControlDriverInstance<'postgres'>, space: string, entry: {
+    readonly edgeId: string;
+    readonly from: string;
+    readonly to: string;
+    readonly migrationName: string;
+    readonly migrationHash: string;
+    readonly operations: readonly unknown[];
+    readonly destinationContractJson?: unknown;
+  }): Promise<void>;
+  private assertMarkerTableHasSpaceColumn;
+  private readMarkerResult;
+  /**
+   * 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.
+   *
+   * When `contract` is provided and its storage declares more than one
+   * namespace (or any explicit bound namespace), the adapter walks every
+   * declared namespace and merges the per-schema introspection results
+   * into a single `SqlSchemaIR`. `UNBOUND_NAMESPACE_ID` resolves to the
+   * connection's `current_schema()` so late-bound tables follow the
+   * runtime `search_path`. When no contract is passed, the adapter falls
+   * back to introspecting the single `schema` argument (defaulting to
+   * `'public'`).
+   *
+   * Uses batched queries to minimize database round trips (6 queries per
+   * schema walked).
+   *
+   * @param driver - SqlControlDriverInstance<'postgres'> instance for executing queries
+   * @param contract - Optional contract for contract-guided introspection (multi-namespace walk, filtering)
+   * @param schema - Schema name to introspect when no contract is provided (defaults to 'public')
+   * @returns Promise resolving to SqlSchemaIR representing the live database schema
+   */
+  introspect(driver: SqlControlDriverInstance<'postgres'>, contract?: unknown, schema?: string): Promise<PostgresDatabaseSchemaNode>;
+  /**
+   * Reads cluster-scoped database roles. Roles are not schema-qualified, so
+   * this is queried once for the whole database rather than per namespace.
+   */
+  private introspectRoles;
+  /**
+   * Lists every non-system schema present in the connected database.
+   * The introspection consumer (`verifyPostgresNamespacePresence`)
+   * treats the result as the authoritative ground truth — declared
+   * namespaces whose `ddlSchemaName` is missing from this list become
+   * `missing_schema` issues, and the planner emits the matching
+   * `CREATE SCHEMA` before table DDL.
+   */
+  private listExistingSchemas;
+  /**
+   * Resolves the declared namespace ids to their live DDL schema names,
+   * mapping `UNBOUND_NAMESPACE_ID` to the connection's `current_schema()`
+   * and de-duplicating. The caller introspects one namespace node per
+   * resolved schema — there is no flat cross-schema merge, so two schemas
+   * holding a same-named table no longer collide.
+   */
+  private resolveNamespaceSchemas;
+  /**
+   * Introspects a single Postgres schema and returns the namespace node for
+   * that schema (its tables, their policies, and its native enum type names),
+   * alongside the cluster-scoped Postgres version. Used by `introspect` as
+   * the per-namespace walk.
+   */
+  private introspectSchema;
+  /**
+   * Gets the Postgres version from the database.
+   */
+  private getPostgresVersion;
+}
+//#endregion
+//#region src/exports/control.d.ts
+declare const postgresAdapterDescriptor: SqlControlAdapterDescriptor<'postgres'>;
+//#endregion
+export { postgresAdapterDescriptor as i, createPostgresBuiltinCodecLookup as n, createPostgresCodecRegistryWithBuiltins as r, PostgresControlAdapter as t };
+//# sourceMappingURL=control-D85zv_aY.d.mts.map

package/dist/control-D85zv_aY.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-D85zv_aY.d.mts","names":[],"sources":["../../../../3-targets/6-adapters/postgres/dist/control.d.mts"],"mappings":";;;;;;;;;;;;;;;;;iBAciB,wCAAwC,4BAA4B,+BAA+B;;;;;;iBAMnG,oCAAoC;;;;;;;cAOvC,kCAAkC;mBAC7B;WACR;WACA;EACT,YAAY,eAAe;;;;;WAKlB,yBAAyB;;;;;;WAMzB,4BAA4B;EACrC,yCAAyC;EACzC,uCAAuC;;;;;;;;;EASvC,MAAM,KAAK,cAAc,iBAAiB,SAAS,0BAA0B;;;;;;;;EAQ7E,sBAAsB,KAAK,cAAc,iBAAiB,UAAU,0BAA0B,QAAQ;;;;;;;;;EAStG,WAAW,QAAQ,sCAAsC,gBAAgB,QAAQ;EACjF,wBAAwB,QAAQ,sCAAsC,gBAAgB,QAAQ;;;;;;;EAO9F,eAAe,QAAQ,uCAAuC,QAAQ,oBAAoB;UAClF;;;;;;;EAOR,WAAW,QAAQ,sCAAsC,iBAAiB,iBAAiB;UACnF;;;;;;EAMR,aAAa,QAAQ,sCAAsC,eAAe;aAC/D;aACA;aACA;MACP;EACJ,WAAW,QAAQ,sCAAsC,eAAe;aAC7D;aACA;aACA;MACP;;;;;EAKJ,aAAa,QAAQ,sCAAsC,eAAe,sBAAsB;aACrF;aACA;aACA;MACP;;;;;;;;;EASJ,iBAAiB,QAAQ,sCAAsC,eAAe;aACnE;aACA;aACA;aACA;aACA;aACA;aACA;MACP;UACI;UACA;;;;;;;;;;;;;;;;;;;;;;;;;EAyBR,WAAW,QAAQ,sCAAsC,oBAAoB,kBAAkB,QAAQ;;;;;UAK/F;;;;;;;;;UASA;;;;;;;;UAQA;;;;;;;UAOA;;;;UAIA;;;;cAII,2BAA2B"}