@prisma-next/target-postgres 0.14.0 → 0.15.0-dev.10

package/dist/planner-sql-checks.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"mappings":";;;;;;AAiBA;;;;AAA8D;AAgI9D;;;;iBAhIgB,gBAAA,CAAiB,MAAA,UAAgB,KAAa;AAAA,iBAgI9C,uBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,GAAA,SAAY,iBAAA,GACxB,YAAA,GAAc,MAAA,SAAe,mBAAA"}
+{"version":3,"file":"planner-sql-checks.d.mts","names":[],"sources":["../src/core/migrations/planner-sql-checks.ts"],"mappings":";;;;;;AAiBA;;;;AAA8D;AAgI9D;;;;iBAhIgB,gBAAA,CAAiB,MAAA,UAAgB,KAAa;AAAA,iBAgI9C,uBAAA,CACd,MAAA,EAAQ,aAAA,EACR,UAAA,EAAY,WAAA,SAAoB,iBAAA,GAChC,YAAA,GAAc,MAAA,SAAe,mBAAA"}

package/dist/planner-sql-checks.mjs

@@ -1,2 +1,2 @@
-import { n as qualifyTableName, t as buildExpectedFormatType } from "./planner-sql-checks-jqUUGyQR.mjs";
+import { n as qualifyTableName, t as buildExpectedFormatType } from "./planner-sql-checks-zqNfs2XZ.mjs";
 export { buildExpectedFormatType, qualifyTableName };

package/dist/{planner-target-details-CIY6tLeo.d.mts → planner-target-details-HkP4RrRO.d.mts}

@@ -1,5 +1,5 @@
 //#region src/core/migrations/planner-target-details.d.ts
-type OperationClass = 'dependency' | 'type' | 'table' | 'column' | 'primaryKey' | 'unique' | 'index' | 'foreignKey' | 'checkConstraint';
+type OperationClass = 'dependency' | 'type' | 'table' | 'column' | 'primaryKey' | 'unique' | 'index' | 'foreignKey' | 'checkConstraint' | 'rlsPolicy' | 'rowLevelSecurity';
 interface PostgresPlanTargetDetails {
   readonly schema: string;
   readonly objectType: OperationClass;
@@ -8,4 +8,4 @@ interface PostgresPlanTargetDetails {
 }
 //#endregion
 export { PostgresPlanTargetDetails as t };
-//# sourceMappingURL=planner-target-details-CIY6tLeo.d.mts.map
+//# sourceMappingURL=planner-target-details-HkP4RrRO.d.mts.map

package/dist/planner-target-details-HkP4RrRO.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"planner-target-details-HkP4RrRO.d.mts","names":[],"sources":["../src/core/migrations/planner-target-details.ts"],"mappings":";KAEY,cAAA;AAAA,UAaK,yBAAA;EAAA,SACN,MAAA;EAAA,SACA,UAAA,EAAY,cAAc;EAAA,SAC1B,IAAA;EAAA,SACA,KAAA;AAAA"}

package/dist/planner-target-details.d.mts

@@ -1,2 +1,2 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO.mjs";
 export type { PostgresPlanTargetDetails };

package/dist/planner.d.mts

@@ -1,10 +1,35 @@
-import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-QqHa2C2l.mjs";
-import { MigrationOperationPolicy, SqlPlannerConflict, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
-import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext } from "@prisma-next/framework-components/control";
+import { t as PostgresDatabaseSchemaNode } from "./postgres-database-schema-node-DJOTywwQ.mjs";
+import { t as PostgresContract } from "./postgres-schema-DKq6s1P3.mjs";
+import { t as TypeScriptRenderablePostgresMigration } from "./planner-produced-postgres-migration-k33bb9Sm.mjs";
+import { ContractToSchemaIROptions, MigrationOperationPolicy, SqlPlannerConflict, SqlPlannerFailureResult } from "@prisma-next/family-sql/control";
+import { MigrationPlanWithAuthoringSurface, MigrationPlanner, MigrationScaffoldContext, SchemaOwnership } from "@prisma-next/framework-components/control";
 import { Contract } from "@prisma-next/contract/types";
 import { ExecuteRequestLowerer } from "@prisma-next/family-sql/control-adapter";
 import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
 
+//#region src/core/migrations/contract-to-postgres-database-schema-node.d.ts
+/**
+ * Projects a Postgres contract into the expected schema-diff tree: a
+ * `PostgresDatabaseSchemaNode` root holding one `PostgresNamespaceSchemaNode`
+ * per Postgres namespace, each holding its `PostgresTableSchemaNode`s with
+ * their `PostgresPolicySchemaNode`s, plus the database roles on the root.
+ *
+ * Not a duplicate of the family's `contractToSchemaIR`: that builds a flat,
+ * single `{ tables }` map (and throws on cross-namespace name collisions, with
+ * no RLS/role concept) for SQLite's single-schema world. This is the
+ * Postgres-specific *tree* shape — multi-schema, RLS-policy-aware, role-aware.
+ * It reuses the family's per-namespace table conversion (`contractNamespaceToSchemaIR`)
+ * for column/FK/index building and only adds the Postgres tree/policy/role shape.
+ *
+ * Tables are grouped by their owning namespace (resolved DDL schema name) so
+ * the tree mirrors Postgres's object hierarchy. The DDL schema name is
+ * resolved once per namespace.
+ *
+ * A policy that references a table absent from its namespace is a malformed
+ * contract — the loop throws rather than fabricating a stub table.
+ */
+declare function contractToPostgresDatabaseSchemaNode(contract: PostgresContract | null, options: ContractToSchemaIROptions): PostgresDatabaseSchemaNode;
+//#endregion
 //#region src/core/migrations/planner.d.ts
 declare function createPostgresMigrationPlanner(lowerer: ExecuteRequestLowerer): PostgresMigrationPlanner;
 /**
@@ -22,18 +47,20 @@ type PostgresPlanResult = {
 /**
  * Postgres migration planner — a thin wrapper over `planIssues`.
  *
- * `plan()` verifies the live schema against the target contract (producing
- * `SchemaIssue[]`) and delegates to `planIssues` with the unified
- * `postgresPlannerStrategies` list: enum-change, NOT-NULL backfill,
- * type-change, nullable-tightening, codec-hook storage types,
- * component-declared dependency installs, and shared-temp-default /
- * empty-table-guarded NOT-NULL add-column. The same strategy list runs for
- * `migration plan`, `db update`, and `db init`; behavior diverges purely on
- * `policy.allowedOperationClasses` (the data-safe strategies short-circuit
- * when `'data'` is excluded). The issue planner applies operation-class
- * policy gates and emits a single `PostgresOpFactoryCall[]` that drives both
- * the runtime-ops view (via `renderOps`) and the `renderTypeScript()`
- * authoring surface.
+ * `plan()` diffs the target contract against the live schema via the one
+ * differ (`buildPostgresPlanDiff`, producing node-typed `SchemaDiffIssue[]`)
+ * and delegates to `planIssues` with the unified `postgresPlannerStrategies`
+ * list: NOT-NULL backfill, type-change, nullable-tightening, codec-hook
+ * storage types, component-declared dependency installs, and
+ * shared-temp-default / empty-table-guarded NOT-NULL add-column. The same
+ * strategy list runs for `migration plan`, `db update`, and `db init`;
+ * behavior diverges purely on `policy.allowedOperationClasses` (the
+ * data-safe strategies short-circuit when `'data'` is excluded). The issue
+ * planner applies operation-class policy gates and emits a single
+ * `PostgresOpFactoryCall[]` that drives both the runtime-ops view (via
+ * `renderOps`) and the `renderTypeScript()` authoring surface. RLS policy
+ * drift (the structural half of the same one-differ tree) is handled
+ * separately via `planPostgresSchemaDiff`.
  */
 declare class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postgres'> {
   #private;
@@ -65,12 +92,40 @@ declare class PostgresMigrationPlanner implements MigrationPlanner<'sql', 'postg
      * the marker row by the right space.
      */
     readonly spaceId: string;
+    /**
+     * Ownership oracle over the contract-space composition — see
+     * {@link SqlMigrationPlannerPlanOptions.ownership}.
+     */
+    readonly ownership?: SchemaOwnership;
   }): PostgresPlanResult;
   emptyMigration(context: MigrationScaffoldContext, spaceId: string): MigrationPlanWithAuthoringSurface;
   private planSql;
+  /**
+   * Maps the RLS policy presence findings of the one combined tree diff
+   * (`buildPostgresPlanDiff`, already ownership-filtered) into
+   * `CREATE POLICY` / `DROP POLICY` / `ALTER POLICY … RENAME TO` ops. It
+   * does not re-diff — it consumes exactly the policy-node subset of the
+   * shared diff's issues. Enablement is NOT decided here: `ENABLE`/`DISABLE
+   * ROW LEVEL SECURITY` derive from the table's marker-driven `rlsEnabled`
+   * attribute diff on the relational side.
+   *
+   * Rename post-pass: a `not-found` and a `not-expected` policy on the SAME
+   * table whose wire-name content hashes match but prefixes differ are one
+   * prefix-only rename, collapsed into a single non-destructive
+   * `RenamePostgresRlsPolicyCall`. Multi-candidate hash groups pair
+   * deterministically by sorted wire name; leftovers proceed as
+   * create/drop. Unparseable wire names never pair.
+   *
+   * The pairing runs only when the policy allows `widening` (rename's
+   * class). Without it (db-init's additive-only set), pairing degrades
+   * deliberately to the additive half: the new name is CREATEd and the old
+   * policy survives live until a widening/destructive-allowed plan runs —
+   * emitting an ungated widening rename would only fail at the runner's
+   * class re-enforcement.
+   */
+  private planPostgresSchemaDiff;
   private ensureAdditivePolicy;
-  private collectSchemaIssues;
 }
 //#endregion
-export { createPostgresMigrationPlanner };
+export { contractToPostgresDatabaseSchemaNode, createPostgresMigrationPlanner };
 //# sourceMappingURL=planner.d.mts.map

package/dist/planner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/planner.ts"],"mappings":";;;;;;;;iBAqDgB,8BAAA,CACd,OAAA,EAAS,qBAAA,GACR,wBAAwB;;AAF3B;;;;;;KAaY,kBAAA;EAAA,SAEG,IAAA;EAAA,SACA,IAAA,EAAM,qCAAA;EAAA,SACN,QAAA,YAAoB,kBAAA;AAAA,IAE/B,uBAAA;;;;;;;;;;;;;;AAAuB;AAkB3B;;cAAa,wBAAA,YAAoC,gBAAA;EAAA;cAGnC,OAAA,GAAU,qBAAA;EAItB,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IA6BR;;;;;;;;;;;;;;IAAA,SAdA,YAAA,EAAc,QAAA;IAAA,SACd,UAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IADnC;;;;;IAAA,SAOA,OAAA;EAAA,IACP,kBAAA;EAIJ,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;EAAA,QAYK,OAAA;EAAA,QAmGA,oBAAA;EAAA,QAaA,mBAAA;AAAA"}
+{"version":3,"file":"planner.d.mts","names":[],"sources":["../src/core/migrations/contract-to-postgres-database-schema-node.ts","../src/core/migrations/planner.ts"],"mappings":";;;;;;;;;;;;;;;;;AA6FA;;;;;;;;;;;;;iBAAgB,oCAAA,CACd,QAAA,EAAU,gBAAA,SACV,OAAA,EAAS,yBAAA,GACR,0BAAA;;;iBC/Ba,8BAAA,CACd,OAAA,EAAS,qBAAA,GACR,wBAAwB;;;;AD0B3B;;;;KCfY,kBAAA;EAAA,SAEG,IAAA;EAAA,SACA,IAAA,EAAM,qCAAA;EAAA,SACN,QAAA,YAAoB,kBAAA;AAAA,IAE/B,uBAAA;;;;;;ADYyB;;;;AC/B7B;;;;;;;;AAE2B;cAqCd,wBAAA,YAAoC,gBAAA;EAAA;cAGnC,OAAA,GAAU,qBAAA;EAItB,IAAA,CAAK,OAAA;IAAA,SACM,QAAA;IAAA,SACA,MAAA;IAAA,SACA,MAAA,EAAQ,wBAAA;IA9BM;;;;;;;;AAAA;AAoB3B;;;;;IApB2B,SA6Cd,YAAA,EAAc,QAAA;IAAA,SACd,UAAA;IAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;IAWvB;;;;;IAAA,SALZ,OAAA;IAjCoD;;;;IAAA,SAsCpD,SAAA,GAAY,eAAA;EAAA,IACnB,kBAAA;EAIJ,cAAA,CACE,OAAA,EAAS,wBAAA,EACT,OAAA,WACC,iCAAA;EAAA,QAYK,OAAA;EAjDG;;;;;;;;;;;;;;;;;;;;;;;EAAA,QAiPH,sBAAA;EAAA,QAiHA,oBAAA;AAAA"}

package/dist/planner.mjs

@@ -1,2 +1,3 @@
-import { t as createPostgresMigrationPlanner } from "./planner-Bs_baQax.mjs";
-export { createPostgresMigrationPlanner };
+import { r as contractToPostgresDatabaseSchemaNode } from "./diff-database-schema-oY3brcLj.mjs";
+import { t as createPostgresMigrationPlanner } from "./planner-ootbxGty.mjs";
+export { contractToPostgresDatabaseSchemaNode, createPostgresMigrationPlanner };

package/dist/postgres-contract-view-C9j5cqP0.d.mts

@@ -0,0 +1,34 @@
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlSchemaQualifiedView } from "@prisma-next/sql-contract/contract-view";
+import { Contract } from "@prisma-next/contract/types";
+
+//#region src/core/postgres-contract-view.d.ts
+/**
+ * A schema-qualified Postgres contract view: the deserialized contract
+ * intersected with a single `namespace` member holding every schema by id. It is
+ * substitutable for `Contract` (carries `storage`, `domain`, …) and reaches each
+ * schema's entities through `view.namespace.<schema>`:
+ *
+ * ```ts
+ * const view = PostgresContractView.fromJson<Contract>(contractJson);
+ * view.namespace.public.table.users      // typed table leaf in the public schema
+ * view.namespace.auth.table.users        // the auth schema's own users table
+ * view.namespace.public.entries.policy.X // pack-contributed kind (RLS / #771 path)
+ * view.namespace.__unbound__.table.X     // default schema, keyed by its raw id
+ * view.storage                           // the full contract is still present
+ * ```
+ *
+ * This mirrors the runtime `db.enums.<ns>` keying exactly (the default schema
+ * keeps its literal `__unbound__` id). Schema names are NOT promoted to the
+ * contract root, so there is no collision with contract envelope fields — a
+ * schema named `storage` is `view.namespace.storage`, while `view.storage`
+ * stays the contract's `storage`.
+ */
+type PostgresContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> = SqlSchemaQualifiedView<TContract>;
+declare const PostgresContractView: {
+  /** Wrap an already-deserialized Postgres contract in a schema-qualified view. */from<TContract extends Contract<SqlStorage>>(contract: TContract): PostgresContractView<TContract>; /** Deserialize a Postgres contract JSON envelope and wrap it in a view. */
+  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage<string>>>(json: unknown): PostgresContractView<TContract>;
+};
+//#endregion
+export { PostgresContractView as t };
+//# sourceMappingURL=postgres-contract-view-C9j5cqP0.d.mts.map

package/dist/postgres-contract-view-C9j5cqP0.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-contract-view-C9j5cqP0.d.mts","names":[],"sources":["../src/core/postgres-contract-view.ts"],"mappings":";;;;;;;AA6BA;;;;;;;;;;;;;;;;;;;KAAY,oBAAA,mBAAuC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,KACjF,sBAAA,CAAuB,SAAA;AAAA,cAEZ,oBAAA;EAeZ,wGAbwB,QAAA,CAAS,UAAA,GAAW,QAAA,EAC/B,SAAA,GACT,oBAAA,CAAqB,SAAA,GAFQ;6BAOL,QAAA,CAAS,UAAA,IAAW,QAAA,CAAA,UAAA,WAAA,IAAA,YAE5C,oBAAA,CAAqB,SAAA;AAAA"}

package/dist/{postgres-contract-serializer-k3TAcPMY.mjs → postgres-contract-view-DM8sN1Ot.mjs}

@@ -1,16 +1,22 @@
-import { r as postgresAuthoringEntityTypes, t as postgresTargetDescriptorMeta } from "./descriptor-meta-CpGygXpI.mjs";
-import { r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
+import { m as PG_INT_CODEC_ID, y as PG_TEXT_CODEC_ID } from "./codec-ids-B10ZZHzw.mjs";
+import { a as nativeEnumEntityKind, c as roleEntityKind, o as policyEntityKind, s as rlsEnablementEntityKind, t as PostgresSchema } from "./postgres-schema-Cm4DtiGA.mjs";
+import { t as postgresAuthoringEntityTypes } from "./authoring-BtsOWgI3.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { blindCast } from "@prisma-next/utils/casts";
-import { NamespaceBase, UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+import { buildSqlSchemaQualifiedView } from "@prisma-next/sql-contract/contract-view";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { isAuthoringEntityTypeDescriptor } from "@prisma-next/framework-components/authoring";
 //#region src/core/postgres-contract-serializer.ts
 const POSTGRES_AUTHORING_CTX = {
 	family: "sql",
-	target: "postgres"
+	target: "postgres",
+	enumInferenceCodecs: {
+		text: PG_TEXT_CODEC_ID,
+		int: PG_INT_CODEC_ID
+	}
 };
 function isAuthoringEntityTypeFactoryOutput(output) {
-	return typeof output === "object" && output !== null && typeof output.factory === "function";
+	return typeof output === "object" && output !== null && "factory" in output && typeof output.factory === "function";
 }
 /**
 * Walks a pack's entity-type namespace tree and emits hydration factories
@@ -36,20 +42,22 @@ function collectStorageTypesHydrators(namespace) {
 	return registry;
 }
 var PostgresContractSerializer = class extends SqlContractSerializerBase {
-	constructor() {
+	constructor(extraPackEntityKinds = []) {
 		const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);
-		super(storageTypesHydrators);
-	}
-	get defaultNamespaceId() {
-		return postgresTargetDescriptorMeta.defaultNamespaceId;
+		super(storageTypesHydrators, [
+			policyEntityKind,
+			roleEntityKind,
+			rlsEnablementEntityKind,
+			nativeEnumEntityKind,
+			...extraPackEntityKinds
+		]);
 	}
 	hydrateSqlNamespaceEntry(nsId, raw) {
-		if (raw instanceof NamespaceBase) return raw;
 		const { id, entries } = blindCast(super.hydrateSqlNamespaceEntry(nsId, raw));
+		const allSlotsEmpty = Object.values(entries).every((slot) => slot === void 0 || Object.keys(slot).length === 0);
+		if (id === UNBOUND_NAMESPACE_ID && allSlotsEmpty) return PostgresSchema.unbound;
 		const valueSetSlot = entries["valueSet"];
 		const hasValueSets = valueSetSlot !== void 0 && Object.keys(valueSetSlot).length > 0;
-		const emptyTables = Object.keys(entries["table"] ?? {}).length === 0;
-		if (id === UNBOUND_NAMESPACE_ID && emptyTables && !hasValueSets) return PostgresSchema.unbound;
 		return new PostgresSchema({
 			id,
 			entries: {
@@ -62,46 +70,42 @@ var PostgresContractSerializer = class extends SqlContractSerializerBase {
 	serializeContract(contract) {
 		const { storage, ...rest } = contract;
 		const namespacesJson = {};
-		for (const [nsId, ns] of Object.entries(storage.namespaces)) if (isPostgresSchema(ns)) namespacesJson[nsId] = this.serializePostgresNamespace(ns, ns.id === UNBOUND_NAMESPACE_ID);
-		else namespacesJson[nsId] = {
-			id: nsId,
-			kind: nsId === UNBOUND_NAMESPACE_ID ? "postgres-unbound-schema" : "postgres-schema",
-			entries: { table: Object.fromEntries(Object.entries(ns.entries.table ?? {}).map(([tableName, table]) => [tableName, this.serializeJsonValue(table)])) }
-		};
+		for (const [nsId, ns] of Object.entries(storage.namespaces)) {
+			const isUnboundSlot = ns.id === UNBOUND_NAMESPACE_ID;
+			namespacesJson[nsId] = {
+				id: ns.id,
+				kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
+				entries: this.serializeNamespaceEntries(ns.entries)
+			};
+		}
 		const storageOut = {
 			storageHash: String(storage.storageHash),
 			namespaces: namespacesJson
 		};
 		if (storage.types !== void 0) {
 			const typesOut = {};
-			for (const [name, entry] of Object.entries(storage.types)) typesOut[name] = this.serializeJsonValue(entry);
+			for (const [name, entry] of Object.entries(storage.types)) typesOut[name] = this.serializeJsonObject(entry);
 			storageOut["types"] = typesOut;
 		}
-		return {
+		return blindCast({
 			...rest,
 			storage: storageOut
-		};
-	}
-	serializePostgresNamespace(ns, isUnboundSlot) {
-		const tablesOut = {};
-		for (const [tableName, table] of Object.entries(ns.table)) tablesOut[tableName] = this.serializeJsonValue(table);
-		const valueSetEntries = ns.valueSet;
-		const valueSetOut = {};
-		if (valueSetEntries !== void 0) for (const [valueSetName, valueSet] of Object.entries(valueSetEntries)) valueSetOut[valueSetName] = blindCast(this.serializeJsonValue(valueSet));
-		return {
-			id: ns.id,
-			kind: isUnboundSlot ? "postgres-unbound-schema" : "postgres-schema",
-			entries: {
-				table: tablesOut,
-				...Object.keys(valueSetOut).length > 0 ? { valueSet: valueSetOut } : {}
-			}
-		};
+		});
 	}
-	serializeJsonValue(value) {
-		return JSON.parse(JSON.stringify(value));
+};
+//#endregion
+//#region src/core/postgres-contract-view.ts
+const PostgresContractView = {
+	/** Wrap an already-deserialized Postgres contract in a schema-qualified view. */
+	from(contract) {
+		return buildSqlSchemaQualifiedView(contract);
+	},
+	/** Deserialize a Postgres contract JSON envelope and wrap it in a view. */
+	fromJson(json) {
+		return buildSqlSchemaQualifiedView(new PostgresContractSerializer().deserializeContract(json));
 	}
 };
 //#endregion
-export { PostgresContractSerializer as t };
+export { PostgresContractSerializer as n, PostgresContractView as t };
 
-//# sourceMappingURL=postgres-contract-serializer-k3TAcPMY.mjs.map
+//# sourceMappingURL=postgres-contract-view-DM8sN1Ot.mjs.map

package/dist/postgres-contract-view-DM8sN1Ot.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-contract-view-DM8sN1Ot.mjs","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/core/postgres-contract-view.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport {\n  SqlContractSerializerBase,\n  type SqlEntityHydrationFactory,\n} from '@prisma-next/family-sql/ir';\nimport {\n  type AuthoringEntityContext,\n  type AuthoringEntityTypeFactoryOutput,\n  type AuthoringEntityTypeNamespace,\n  isAuthoringEntityTypeDescriptor,\n} from '@prisma-next/framework-components/authoring';\nimport {\n  type AnyEntityKindDescriptor,\n  type Namespace,\n  UNBOUND_NAMESPACE_ID,\n} from '@prisma-next/framework-components/ir';\nimport type { SqlNamespaceInput, SqlStorage } from '@prisma-next/sql-contract/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { JsonObject } from '@prisma-next/utils/json';\nimport { postgresAuthoringEntityTypes } from './authoring';\nimport { PG_INT_CODEC_ID, PG_TEXT_CODEC_ID } from './codec-ids';\nimport {\n  nativeEnumEntityKind,\n  policyEntityKind,\n  rlsEnablementEntityKind,\n  roleEntityKind,\n} from './entity-kinds';\nimport { PostgresSchema } from './postgres-schema';\n\nconst POSTGRES_AUTHORING_CTX: AuthoringEntityContext = {\n  family: 'sql',\n  target: 'postgres',\n  enumInferenceCodecs: { text: PG_TEXT_CODEC_ID, int: PG_INT_CODEC_ID },\n};\n\nfunction isAuthoringEntityTypeFactoryOutput(\n  output: unknown,\n): output is AuthoringEntityTypeFactoryOutput<unknown, unknown> {\n  return (\n    typeof output === 'object' &&\n    output !== null &&\n    'factory' in output &&\n    typeof output.factory === 'function'\n  );\n}\n\n/**\n * Walks a pack's entity-type namespace tree and emits hydration factories\n * keyed by the descriptor's `discriminator`. Used for `storage.types`\n * (codec-triple hydration). Namespace entries hydration dispatches by\n * entries key, not discriminator — handled by `hydrateNamespaceEntities`.\n */\nfunction collectStorageTypesHydrators(\n  namespace: AuthoringEntityTypeNamespace,\n): ReadonlyMap<string, SqlEntityHydrationFactory> {\n  const registry = new Map<string, SqlEntityHydrationFactory>();\n  const walk = (node: AuthoringEntityTypeNamespace): void => {\n    for (const value of Object.values(node)) {\n      if (isAuthoringEntityTypeDescriptor(value)) {\n        if (isAuthoringEntityTypeFactoryOutput(value.output)) {\n          const { factory } = value.output;\n          registry.set(value.discriminator, (raw) => factory(raw, POSTGRES_AUTHORING_CTX));\n        }\n        continue;\n      }\n      if (typeof value === 'object' && value !== null) {\n        walk(value);\n      }\n    }\n  };\n  walk(namespace);\n  return registry;\n}\n\nexport class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {\n  constructor(extraPackEntityKinds: readonly AnyEntityKindDescriptor[] = []) {\n    const storageTypesHydrators = collectStorageTypesHydrators(postgresAuthoringEntityTypes);\n    super(storageTypesHydrators, [\n      policyEntityKind,\n      roleEntityKind,\n      rlsEnablementEntityKind,\n      nativeEnumEntityKind,\n      ...extraPackEntityKinds,\n    ]);\n  }\n\n  protected override hydrateSqlNamespaceEntry(\n    nsId: string,\n    raw: Record<string, unknown>,\n  ): Namespace | SqlNamespaceInput {\n    const hydrated = blindCast<\n      SqlNamespaceInput,\n      'raw is always plain JSON, so super.hydrateSqlNamespaceEntry returns SqlNamespaceInput'\n    >(super.hydrateSqlNamespaceEntry(nsId, raw));\n    const { id, entries } = hydrated;\n\n    const allSlotsEmpty = Object.values(entries).every(\n      (slot) => slot === undefined || Object.keys(slot).length === 0,\n    );\n    if (id === UNBOUND_NAMESPACE_ID && allSlotsEmpty) {\n      return PostgresSchema.unbound;\n    }\n    const valueSetSlot = entries['valueSet'];\n    const hasValueSets = valueSetSlot !== undefined && Object.keys(valueSetSlot).length > 0;\n    return new PostgresSchema({\n      id,\n      entries: {\n        ...entries,\n        table: entries['table'] ?? {},\n        ...(hasValueSets ? { valueSet: valueSetSlot } : {}),\n      },\n    });\n  }\n\n  override serializeContract(contract: Contract<SqlStorage>): JsonObject {\n    const { storage, ...rest } = contract;\n    const namespacesJson: Record<string, JsonObject> = {};\n    // Each namespace serializes to its id, its schema-kind tag, and the\n    // base's generic entries walk — every enumerable kind on\n    // `PostgresSchema.entries`, including `native_enum`.\n    for (const [nsId, ns] of Object.entries(storage.namespaces)) {\n      const isUnboundSlot = ns.id === UNBOUND_NAMESPACE_ID;\n      namespacesJson[nsId] = {\n        id: ns.id,\n        kind: isUnboundSlot ? 'postgres-unbound-schema' : 'postgres-schema',\n        entries: this.serializeNamespaceEntries(ns.entries),\n      };\n    }\n    const storageOut: Record<string, unknown> = {\n      storageHash: String(storage.storageHash),\n      namespaces: namespacesJson,\n    };\n    if (storage.types !== undefined) {\n      const typesOut: Record<string, JsonObject> = {};\n      for (const [name, entry] of Object.entries(storage.types)) {\n        typesOut[name] = this.serializeJsonObject(entry);\n      }\n      storageOut['types'] = typesOut;\n    }\n    return blindCast<\n      JsonObject,\n      'contract minus storage plus a JSON-shaped storageOut is a JsonObject'\n    >({\n      ...rest,\n      storage: storageOut,\n    });\n  }\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport {\n  buildSqlSchemaQualifiedView,\n  type SqlSchemaQualifiedView,\n} from '@prisma-next/sql-contract/contract-view';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { PostgresContractSerializer } from './postgres-contract-serializer';\n\n/**\n * A schema-qualified Postgres contract view: the deserialized contract\n * intersected with a single `namespace` member holding every schema by id. It is\n * substitutable for `Contract` (carries `storage`, `domain`, …) and reaches each\n * schema's entities through `view.namespace.<schema>`:\n *\n * ```ts\n * const view = PostgresContractView.fromJson<Contract>(contractJson);\n * view.namespace.public.table.users      // typed table leaf in the public schema\n * view.namespace.auth.table.users        // the auth schema's own users table\n * view.namespace.public.entries.policy.X // pack-contributed kind (RLS / #771 path)\n * view.namespace.__unbound__.table.X     // default schema, keyed by its raw id\n * view.storage                           // the full contract is still present\n * ```\n *\n * This mirrors the runtime `db.enums.<ns>` keying exactly (the default schema\n * keeps its literal `__unbound__` id). Schema names are NOT promoted to the\n * contract root, so there is no collision with contract envelope fields — a\n * schema named `storage` is `view.namespace.storage`, while `view.storage`\n * stays the contract's `storage`.\n */\nexport type PostgresContractView<TContract extends Contract<SqlStorage> = Contract<SqlStorage>> =\n  SqlSchemaQualifiedView<TContract>;\n\nexport const PostgresContractView = {\n  /** Wrap an already-deserialized Postgres contract in a schema-qualified view. */\n  from<TContract extends Contract<SqlStorage>>(\n    contract: TContract,\n  ): PostgresContractView<TContract> {\n    return buildSqlSchemaQualifiedView(contract);\n  },\n\n  /** Deserialize a Postgres contract JSON envelope and wrap it in a view. */\n  fromJson<TContract extends Contract<SqlStorage> = Contract<SqlStorage>>(\n    json: unknown,\n  ): PostgresContractView<TContract> {\n    const contract = new PostgresContractSerializer().deserializeContract<TContract>(json);\n    return buildSqlSchemaQualifiedView(contract);\n  },\n};\n"],"mappings":";;;;;;;;;AA6BA,MAAM,yBAAiD;CACrD,QAAQ;CACR,QAAQ;CACR,qBAAqB;EAAE,MAAM;EAAkB,KAAK;CAAgB;AACtE;AAEA,SAAS,mCACP,QAC8D;CAC9D,OACE,OAAO,WAAW,YAClB,WAAW,QACX,aAAa,UACb,OAAO,OAAO,YAAY;AAE9B;;;;;;;AAQA,SAAS,6BACP,WACgD;CAChD,MAAM,2BAAW,IAAI,IAAuC;CAC5D,MAAM,QAAQ,SAA6C;EACzD,KAAK,MAAM,SAAS,OAAO,OAAO,IAAI,GAAG;GACvC,IAAI,gCAAgC,KAAK,GAAG;IAC1C,IAAI,mCAAmC,MAAM,MAAM,GAAG;KACpD,MAAM,EAAE,YAAY,MAAM;KAC1B,SAAS,IAAI,MAAM,gBAAgB,QAAQ,QAAQ,KAAK,sBAAsB,CAAC;IACjF;IACA;GACF;GACA,IAAI,OAAO,UAAU,YAAY,UAAU,MACzC,KAAK,KAAK;EAEd;CACF;CACA,KAAK,SAAS;CACd,OAAO;AACT;AAEA,IAAa,6BAAb,cAAgD,0BAAgD;CAC9F,YAAY,uBAA2D,CAAC,GAAG;EACzE,MAAM,wBAAwB,6BAA6B,4BAA4B;EACvF,MAAM,uBAAuB;GAC3B;GACA;GACA;GACA;GACA,GAAG;EACL,CAAC;CACH;CAEA,yBACE,MACA,KAC+B;EAK/B,MAAM,EAAE,IAAI,YAJK,UAGf,MAAM,yBAAyB,MAAM,GAAG,CACX;EAE/B,MAAM,gBAAgB,OAAO,OAAO,OAAO,CAAC,CAAC,OAC1C,SAAS,SAAS,KAAA,KAAa,OAAO,KAAK,IAAI,CAAC,CAAC,WAAW,CAC/D;EACA,IAAI,OAAO,wBAAwB,eACjC,OAAO,eAAe;EAExB,MAAM,eAAe,QAAQ;EAC7B,MAAM,eAAe,iBAAiB,KAAA,KAAa,OAAO,KAAK,YAAY,CAAC,CAAC,SAAS;EACtF,OAAO,IAAI,eAAe;GACxB;GACA,SAAS;IACP,GAAG;IACH,OAAO,QAAQ,YAAY,CAAC;IAC5B,GAAI,eAAe,EAAE,UAAU,aAAa,IAAI,CAAC;GACnD;EACF,CAAC;CACH;CAEA,kBAA2B,UAA4C;EACrE,MAAM,EAAE,SAAS,GAAG,SAAS;EAC7B,MAAM,iBAA6C,CAAC;EAIpD,KAAK,MAAM,CAAC,MAAM,OAAO,OAAO,QAAQ,QAAQ,UAAU,GAAG;GAC3D,MAAM,gBAAgB,GAAG,OAAO;GAChC,eAAe,QAAQ;IACrB,IAAI,GAAG;IACP,MAAM,gBAAgB,4BAA4B;IAClD,SAAS,KAAK,0BAA0B,GAAG,OAAO;GACpD;EACF;EACA,MAAM,aAAsC;GAC1C,aAAa,OAAO,QAAQ,WAAW;GACvC,YAAY;EACd;EACA,IAAI,QAAQ,UAAU,KAAA,GAAW;GAC/B,MAAM,WAAuC,CAAC;GAC9C,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,QAAQ,KAAK,GACtD,SAAS,QAAQ,KAAK,oBAAoB,KAAK;GAEjD,WAAW,WAAW;EACxB;EACA,OAAO,UAGL;GACA,GAAG;GACH,SAAS;EACX,CAAC;CACH;AACF;;;ACnHA,MAAa,uBAAuB;;CAElC,KACE,UACiC;EACjC,OAAO,4BAA4B,QAAQ;CAC7C;;CAGA,SACE,MACiC;EAEjC,OAAO,4BADU,IAAI,2BAA2B,CAAC,CAAC,oBAA+B,IACvC,CAAC;CAC7C;AACF"}

package/dist/postgres-database-schema-node-DJOTywwQ.d.mts

@@ -0,0 +1,271 @@
+import { r as RlsPolicyOperation } from "./postgres-rls-policy--CSddvMR.mjs";
+import { PrimaryKey, SqlAnnotations, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlTableIRInput, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+import { DiffableNode, SchemaNodeRef } from "@prisma-next/framework-components/control";
+import { ControlPolicy } from "@prisma-next/contract/types";
+
+//#region src/core/schema-ir/postgres-native-enum-schema-node.d.ts
+interface PostgresNativeEnumSchemaNodeInput {
+  /** The Postgres type name (`CREATE TYPE <typeName> AS ENUM (…)`). */
+  readonly typeName: string;
+  /** The owning DDL schema name — enum types are schema-scoped. */
+  readonly namespaceId: string;
+  /** Member values in declaration (`pg_enum.enumsortorder`) order. */
+  readonly members: readonly string[];
+  /** The contract entity's control grade — expected-side nodes only. */
+  readonly control?: ControlPolicy;
+}
+/**
+ * Schema-diff leaf node for a native Postgres enum type.
+ *
+ * This is a derived, transient node walked by the differ — it is NEVER
+ * serialized. Both sides derive it on the namespace node: the expected side
+ * from the contract's hydrated `entries.native_enum` entities, the actual
+ * side from the adapter's introspected `nativeEnums`.
+ *
+ * Enum types are schema-scoped, so identity is (namespace, type name): the
+ * namespace coordinate comes from tree position (the differ pairs enum nodes
+ * only inside an already-paired namespace) and `id` carries the type name,
+ * prefixed with the entries-kind vocabulary (`native_enum:<typeName>`) so it
+ * cannot collide with a sibling table of the same name — the same
+ * sibling-prefix convention relational column nodes use (`column:<name>`).
+ *
+ * `isEqualTo` compares members POSITIONALLY — `['a','b'] ≠ ['b','a']` —
+ * because Postgres enum sort order is semantic. `control` is contract
+ * metadata, not database state, and does not participate in equality.
+ */
+declare class PostgresNativeEnumSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-native-enum";
+  readonly typeName: string;
+  readonly namespaceId: string;
+  readonly members: readonly string[];
+  readonly control?: ControlPolicy;
+  constructor(input: PostgresNativeEnumSchemaNodeInput);
+  get id(): string;
+  children(): readonly DiffableNode[];
+  isEqualTo(other: DiffableNode): boolean;
+  static is(node: SqlSchemaIRNode): node is PostgresNativeEnumSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresNativeEnumSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-policy-schema-node.d.ts
+interface PostgresPolicySchemaNodeInput {
+  /** Full wire name: `<prefix>_<8hex>`. */
+  readonly name: string;
+  /** User-supplied prefix (the part before the `_<8hex>` suffix). */
+  readonly prefix: string;
+  /** Name of the table this policy attaches to, by name within the same schema. */
+  readonly tableName: string;
+  /** Namespace coordinate (schema name). */
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  /** Sorted role names rendered in `TO <roles>`. */
+  readonly roles: readonly string[];
+  /** USING predicate SQL string, if present. */
+  readonly using?: string;
+  /** WITH CHECK predicate SQL string, if present. */
+  readonly withCheck?: string;
+  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */
+  readonly permissive: boolean;
+  /**
+   * This policy's table node, plus one entry per role it grants to — each
+   * as the root-anchored chain the differ pairs siblings with. Stamped by
+   * the derivation, which holds the parent (database/namespace) context.
+   * Never compared by `isEqualTo`.
+   */
+  readonly dependsOn?: readonly SchemaNodeRef[];
+}
+/**
+ * Schema-diff leaf node for a Postgres row-level security policy.
+ *
+ * This is a derived, transient node walked by the differ — it is NEVER serialized.
+ * Built by project-from-contract and project-from-database from their respective
+ * `PostgresRlsPolicy` contract entities / introspected rows.
+ *
+ * `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is
+ * body-equality. `isEqualTo` compares names only — never byte-compare predicate
+ * bodies, because Postgres reprints them.
+ */
+declare class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-policy";
+  readonly name: string;
+  readonly prefix: string;
+  readonly tableName: string;
+  readonly namespaceId: string;
+  readonly operation: RlsPolicyOperation;
+  readonly roles: readonly string[];
+  readonly using?: string;
+  readonly withCheck?: string;
+  readonly permissive: boolean;
+  /** See {@link PostgresPolicySchemaNodeInput.dependsOn}. Non-enumerable so it stays out of JSON and structural equality, matching `SqlColumnIR.codecRef`. */
+  readonly dependsOn?: readonly SchemaNodeRef[];
+  constructor(input: PostgresPolicySchemaNodeInput);
+  get id(): string;
+  children(): readonly DiffableNode[];
+  isEqualTo(other: DiffableNode): boolean;
+  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode;
+  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-table-schema-node.d.ts
+interface PostgresTableSchemaNodeInput extends SqlTableIRInput {
+  readonly policies?: readonly PostgresPolicySchemaNode[];
+  /**
+   * Whether row-level security is enabled on this table. Expected side:
+   * stamped from the contract's `entries.rls` marker (never from the
+   * policy set). Actual side: stamped from `pg_class.relrowsecurity` at
+   * introspection. Required with no default so every construction site
+   * supplies a deliberate value.
+   */
+  readonly rlsEnabled: boolean;
+}
+/**
+ * Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields
+ * plus `policies`, and implements `DiffableNode` so the table instance is
+ * directly the diff-tree node — no separate wrapper needed.
+ *
+ * Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because
+ * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents
+ * subclass field initialisation.
+ *
+ * `id` is the table name. `isEqualTo` compares id + `rlsEnabled` — the
+ * table's one own diffable attribute; all other structural drift is
+ * expressed by its children. `children()` returns every column, the primary
+ * key (when present), every foreign key, unique, index, and check constraint,
+ * plus the policy nodes — one flat list, so a drifted column and a drifted
+ * policy are both reported by the same walk. Order is deterministic (object
+ * key order for columns, array order for the rest) so two structurally equal
+ * tables always produce the same child list.
+ */
+declare class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-table";
+  readonly name: string;
+  readonly columns: Readonly<Record<string, SqlColumnIR>>;
+  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;
+  readonly uniques: ReadonlyArray<SqlUniqueIR>;
+  readonly indexes: ReadonlyArray<SqlIndexIR>;
+  readonly primaryKey?: PrimaryKey;
+  readonly annotations?: SqlAnnotations;
+  readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;
+  readonly policies: readonly PostgresPolicySchemaNode[];
+  readonly rlsEnabled: boolean;
+  constructor(input: PostgresTableSchemaNodeInput);
+  get id(): string;
+  /**
+   * Equal iff the ids (names) match AND `rlsEnabled` matches — the table's
+   * one own attribute in the diff; all other structural drift is expressed
+   * by children. A paired `not-equal` therefore always means enablement
+   * drift, which the planner maps to ENABLE/DISABLE ROW LEVEL SECURITY.
+   */
+  isEqualTo(other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-namespace-schema-node.d.ts
+interface PostgresNamespaceSchemaNodeInput {
+  readonly schemaName: string;
+  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
+  /**
+   * The native-enum diff nodes belonging to this namespace, member values in
+   * `pg_enum.enumsortorder` (declaration) order. The expected
+   * (contract-projected) side attaches each node's `control` (the contract
+   * entity's grade); introspection builds nodes with no `control`.
+   */
+  readonly nativeEnums?: readonly PostgresNativeEnumSchemaNode[];
+}
+/**
+ * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a
+ * single namespace. Per-schema consumers (the relational planner,
+ * toSchemaView) read this node's `tables` field structurally via
+ * `blindCast`/`SqlSchemaIRNode` — not through a static `SqlSchemaIR`
+ * assignment — because `nodeKind` carries this node's own literal
+ * (`postgres-namespace`), distinct from `SqlSchemaIR`'s own (`sql-schema`).
+ *
+ * `id` is the schema name; `isEqualTo` is identity on it; `children()` returns
+ * the table nodes plus `nativeEnums`.
+ *
+ * `nativeEnums` is the diff-tree representation of native enum types the
+ * differ pairs — the sole enum carrier, built directly by both sides: the
+ * expected (contract-projected) side and introspection alike hand in
+ * `PostgresNativeEnumSchemaNode`s.
+ */
+declare class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-namespace";
+  readonly schemaName: string;
+  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;
+  readonly nativeEnums: readonly PostgresNativeEnumSchemaNode[];
+  constructor(input: PostgresNamespaceSchemaNodeInput);
+  get id(): string;
+  isEqualTo(other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-role-schema-node.d.ts
+interface PostgresRoleSchemaNodeInput {
+  readonly name: string;
+  /**
+   * Namespace coordinate. Roles are cluster-scoped; callers pass
+   * `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`.
+   */
+  readonly namespaceId: string;
+}
+/**
+ * Schema-diff leaf node for a Postgres database role.
+ *
+ * This is a derived, transient node walked by the differ — it is NEVER serialized.
+ * Built by project-from-contract and project-from-database from their respective
+ * `PostgresRole` contract entities / introspected rows.
+ *
+ * Roles are cluster-scoped, so `id` is the bare role name. The differ pairs
+ * siblings by `(nodeKind, id)`, so a role and a namespace may share a name
+ * (role `public`, schema `public`) without colliding. `isEqualTo` compares
+ * ids — name-equality is role-equality for cluster-scoped objects.
+ */
+declare class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-role";
+  readonly name: string;
+  readonly namespaceId: string;
+  constructor(input: PostgresRoleSchemaNodeInput);
+  get id(): string;
+  children(): readonly DiffableNode[];
+  isEqualTo(other: DiffableNode): boolean;
+  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode;
+}
+//#endregion
+//#region src/core/schema-ir/postgres-database-schema-node.d.ts
+interface PostgresDatabaseSchemaNodeInput {
+  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;
+  readonly roles: readonly PostgresRoleSchemaNode[];
+  readonly existingSchemas: readonly string[];
+  readonly pgVersion: string;
+}
+/**
+ * The root of the Postgres schema-diff tree: one node per database.
+ *
+ * `id` is the fixed sentinel `'database'` — the root has no siblings and
+ * the value is never emitted into migration paths. `isEqualTo` is identity
+ * (roots always share the `'database'` id). `children()` yields the namespace
+ * nodes followed by the role nodes — both are root-level diff subjects. The
+ * differ pairs siblings by `(nodeKind, id)`, so a role and a namespace may
+ * share a name without colliding.
+ */
+declare class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {
+  readonly nodeKind: "postgres-database";
+  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;
+  readonly roles: readonly PostgresRoleSchemaNode[];
+  readonly existingSchemas: readonly string[];
+  readonly pgVersion: string;
+  constructor(input: PostgresDatabaseSchemaNodeInput);
+  get id(): string;
+  isEqualTo(other: DiffableNode): boolean;
+  children(): readonly DiffableNode[];
+  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode;
+  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode;
+}
+//#endregion
+export { PostgresNamespaceSchemaNode as a, PostgresTableSchemaNodeInput as c, PostgresNativeEnumSchemaNode as d, PostgresNativeEnumSchemaNodeInput as f, PostgresRoleSchemaNodeInput as i, PostgresPolicySchemaNode as l, PostgresDatabaseSchemaNodeInput as n, PostgresNamespaceSchemaNodeInput as o, PostgresRoleSchemaNode as r, PostgresTableSchemaNode as s, PostgresDatabaseSchemaNode as t, PostgresPolicySchemaNodeInput as u };
+//# sourceMappingURL=postgres-database-schema-node-DJOTywwQ.d.mts.map

package/dist/postgres-database-schema-node-DJOTywwQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-database-schema-node-DJOTywwQ.d.mts","names":[],"sources":["../src/core/schema-ir/postgres-native-enum-schema-node.ts","../src/core/schema-ir/postgres-policy-schema-node.ts","../src/core/schema-ir/postgres-table-schema-node.ts","../src/core/schema-ir/postgres-namespace-schema-node.ts","../src/core/schema-ir/postgres-role-schema-node.ts","../src/core/schema-ir/postgres-database-schema-node.ts"],"mappings":"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"}