@prisma-next/target-postgres 0.14.0-dev.39 → 0.14.0-dev.40

package/dist/postgres-table-schema-node-1nNc8XDT.mjs

@@ -0,0 +1,248 @@
+import { blindCast } from "@prisma-next/utils/casts";
+import { freezeNode } from "@prisma-next/framework-components/ir";
+import { PrimaryKey, SqlCheckConstraintIR, SqlColumnIR, SqlForeignKeyIR, SqlIndexIR, SqlSchemaIRNode, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/schema-ir/schema-node-kinds.ts
+/**
+* The `nodeKind` discriminant for each Postgres schema-diff node. Each node
+* carries a unique value; the static `is`/`assert` guards compare against these
+* identifiers rather than spelling the string inline or using `instanceof`. The
+* field is an enumerable own property carried on every node instance.
+*/
+const PostgresSchemaNodeKind = {
+	database: "postgres-database",
+	namespace: "postgres-namespace",
+	table: "postgres-table",
+	policy: "postgres-policy",
+	role: "postgres-role"
+};
+//#endregion
+//#region src/core/schema-ir/postgres-database-schema-node.ts
+/**
+* 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()` returns namespace
+* nodes only; roles are held on the root but not yielded (role diffing is a
+* later slice).
+*/
+var PostgresDatabaseSchemaNode = class PostgresDatabaseSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.database;
+	namespaces;
+	roles;
+	existingSchemas;
+	pgVersion;
+	constructor(input) {
+		super();
+		this.namespaces = Object.freeze({ ...input.namespaces });
+		this.roles = Object.freeze([...input.roles]);
+		this.existingSchemas = Object.freeze([...input.existingSchemas]);
+		this.pgVersion = input.pgVersion;
+		freezeNode(this);
+	}
+	get id() {
+		return "database";
+	}
+	isEqualTo(other) {
+		return this.id === other.id;
+	}
+	children() {
+		return Object.values(this.namespaces);
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.database;
+	}
+	static assert(node) {
+		if (!PostgresDatabaseSchemaNode.is(node)) throw new Error(`Expected a PostgresDatabaseSchemaNode but got nodeKind=${node.nodeKind ?? "undefined"}`);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-namespace-schema-node.ts
+/**
+* One-per-Postgres-schema diff-tree node. Groups the tables belonging to a
+* single namespace and satisfies the `SqlSchemaIR` shape so legacy per-schema
+* consumers (verifySqlSchema, the relational planner, toSchemaView) can
+* accept it unchanged in Unit 6.
+*
+* `id` is the schema name. `isEqualTo` is identity — two namespace nodes are
+* equal iff their ids (schema names) match. `children()` returns the table
+* nodes. Per-schema metadata is carried on the typed `nativeEnumTypeNames`
+* field, not an annotations bag.
+*/
+var PostgresNamespaceSchemaNode = class PostgresNamespaceSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.namespace;
+	schemaName;
+	tables;
+	nativeEnumTypeNames;
+	constructor(input) {
+		super();
+		this.schemaName = input.schemaName;
+		this.tables = Object.freeze({ ...input.tables });
+		this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
+		freezeNode(this);
+	}
+	get id() {
+		return this.schemaName;
+	}
+	isEqualTo(other) {
+		return this.id === other.id;
+	}
+	children() {
+		return Object.values(this.tables);
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.namespace;
+	}
+	static assert(node) {
+		if (!PostgresNamespaceSchemaNode.is(node)) throw new Error(`Expected a PostgresNamespaceSchemaNode but got nodeKind=${node.nodeKind ?? "undefined"}`);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-policy-schema-node.ts
+/**
+* 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.
+*/
+var PostgresPolicySchemaNode = class PostgresPolicySchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.policy;
+	name;
+	prefix;
+	tableName;
+	namespaceId;
+	operation;
+	roles;
+	permissive;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.prefix = input.prefix;
+		this.tableName = input.tableName;
+		this.namespaceId = input.namespaceId;
+		this.operation = input.operation;
+		this.roles = Object.freeze([...input.roles]);
+		if (input.using !== void 0) this.using = input.using;
+		if (input.withCheck !== void 0) this.withCheck = input.withCheck;
+		this.permissive = input.permissive;
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	children() {
+		return [];
+	}
+	isEqualTo(other) {
+		const node = blindCast(other);
+		PostgresPolicySchemaNode.assert(node);
+		return this.id === node.id;
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.policy;
+	}
+	static assert(node) {
+		if (node === void 0 || !PostgresPolicySchemaNode.is(node)) throw new Error(`Expected a PostgresPolicySchemaNode but got nodeKind=${node?.nodeKind ?? "undefined"}`);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-role-schema-node.ts
+/**
+* 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 role name alone. `isEqualTo` compares
+* names — name-equality is role-equality for cluster-scoped objects.
+*/
+var PostgresRoleSchemaNode = class PostgresRoleSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.role;
+	name;
+	namespaceId;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.namespaceId = input.namespaceId;
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	children() {
+		return [];
+	}
+	isEqualTo(other) {
+		const node = blindCast(other);
+		PostgresRoleSchemaNode.assert(node);
+		return this.id === node.id;
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.role;
+	}
+	static assert(node) {
+		if (!PostgresRoleSchemaNode.is(node)) throw new Error(`Expected a PostgresRoleSchemaNode but got nodeKind=${node.nodeKind ?? "undefined"}`);
+	}
+};
+//#endregion
+//#region src/core/schema-ir/postgres-table-schema-node.ts
+/**
+* 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. `children()` returns the policy nodes on this table.
+* `isEqualTo` is identity — two table nodes are equal iff their ids (names)
+* match. Columns are not compared here; they become child nodes later.
+*/
+var PostgresTableSchemaNode = class PostgresTableSchemaNode extends SqlSchemaIRNode {
+	nodeKind = PostgresSchemaNodeKind.table;
+	name;
+	columns;
+	foreignKeys;
+	uniques;
+	indexes;
+	policies;
+	constructor(input) {
+		super();
+		this.name = input.name;
+		this.columns = Object.freeze(Object.fromEntries(Object.entries(input.columns).map(([key, col]) => [key, col instanceof SqlColumnIR ? col : new SqlColumnIR(col)])));
+		this.foreignKeys = Object.freeze(input.foreignKeys.map((fk) => fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk)));
+		this.uniques = Object.freeze(input.uniques.map((u) => u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u)));
+		this.indexes = Object.freeze(input.indexes.map((i) => i instanceof SqlIndexIR ? i : new SqlIndexIR(i)));
+		if (input.primaryKey !== void 0) this.primaryKey = input.primaryKey instanceof PrimaryKey ? input.primaryKey : new PrimaryKey(input.primaryKey);
+		if (input.annotations !== void 0) this.annotations = input.annotations;
+		if (input.checks !== void 0 && input.checks.length > 0) this.checks = Object.freeze(input.checks.map((c) => c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c)));
+		this.policies = Object.freeze([...input.policies ?? []]);
+		freezeNode(this);
+	}
+	get id() {
+		return this.name;
+	}
+	isEqualTo(other) {
+		return this.id === other.id;
+	}
+	children() {
+		return this.policies;
+	}
+	static is(node) {
+		return node.nodeKind === PostgresSchemaNodeKind.table;
+	}
+	static assert(node) {
+		if (!PostgresTableSchemaNode.is(node)) throw new Error(`Expected a PostgresTableSchemaNode but got nodeKind=${node.nodeKind ?? "undefined"}`);
+	}
+};
+//#endregion
+export { PostgresDatabaseSchemaNode as a, PostgresNamespaceSchemaNode as i, PostgresRoleSchemaNode as n, PostgresPolicySchemaNode as r, PostgresTableSchemaNode as t };
+
+//# sourceMappingURL=postgres-table-schema-node-1nNc8XDT.mjs.map

package/dist/postgres-table-schema-node-1nNc8XDT.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-table-schema-node-1nNc8XDT.mjs","names":[],"sources":["../src/core/schema-ir/schema-node-kinds.ts","../src/core/schema-ir/postgres-database-schema-node.ts","../src/core/schema-ir/postgres-namespace-schema-node.ts","../src/core/schema-ir/postgres-policy-schema-node.ts","../src/core/schema-ir/postgres-role-schema-node.ts","../src/core/schema-ir/postgres-table-schema-node.ts"],"sourcesContent":["import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport type { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\n\n/**\n * A Postgres schema-diff-tree node: a `SqlSchemaIRNode` that also implements\n * `DiffableNode` (the five `Postgres*SchemaNode` classes). `SqlSchemaIRNode`\n * alone is not a `DiffableNode` — its relational subclasses (`SqlColumnIR`, …)\n * carry no `id`/`isEqualTo`/`children` — so this intersection is the honest node\n * type the differ produces and the planner consumes (`SchemaDiff<SqlSchemaDiffNode>`).\n */\nexport type SqlSchemaDiffNode = SqlSchemaIRNode & DiffableNode;\n\n/**\n * The `nodeKind` discriminant for each Postgres schema-diff node. Each node\n * carries a unique value; the static `is`/`assert` guards compare against these\n * identifiers rather than spelling the string inline or using `instanceof`. The\n * field is an enumerable own property carried on every node instance.\n */\nexport const PostgresSchemaNodeKind = {\n  database: 'postgres-database',\n  namespace: 'postgres-namespace',\n  table: 'postgres-table',\n  policy: 'postgres-policy',\n  role: 'postgres-role',\n} as const;\n\nexport type PostgresSchemaNodeKind =\n  (typeof PostgresSchemaNodeKind)[keyof typeof PostgresSchemaNodeKind];\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresNamespaceSchemaNode } from './postgres-namespace-schema-node';\nimport type { PostgresRoleSchemaNode } from './postgres-role-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresDatabaseSchemaNodeInput {\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n}\n\n/**\n * The root of the Postgres schema-diff tree: one node per database.\n *\n * `id` is the fixed sentinel `'database'` — the root has no siblings and\n * the value is never emitted into migration paths. `isEqualTo` is identity\n * (roots always share the `'database'` id). `children()` returns namespace\n * nodes only; roles are held on the root but not yielded (role diffing is a\n * later slice).\n */\nexport class PostgresDatabaseSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.database;\n  readonly namespaces: Readonly<Record<string, PostgresNamespaceSchemaNode>>;\n  readonly roles: readonly PostgresRoleSchemaNode[];\n  readonly existingSchemas: readonly string[];\n  readonly pgVersion: string;\n\n  constructor(input: PostgresDatabaseSchemaNodeInput) {\n    super();\n    this.namespaces = Object.freeze({ ...input.namespaces });\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.pgVersion = input.pgVersion;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return 'database';\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return Object.values(this.namespaces);\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresDatabaseSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.database;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresDatabaseSchemaNode {\n    if (!PostgresDatabaseSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresDatabaseSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresTableSchemaNode } from './postgres-table-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresNamespaceSchemaNodeInput {\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnumTypeNames: readonly string[];\n}\n\n/**\n * One-per-Postgres-schema diff-tree node. Groups the tables belonging to a\n * single namespace and satisfies the `SqlSchemaIR` shape so legacy per-schema\n * consumers (verifySqlSchema, the relational planner, toSchemaView) can\n * accept it unchanged in Unit 6.\n *\n * `id` is the schema name. `isEqualTo` is identity — two namespace nodes are\n * equal iff their ids (schema names) match. `children()` returns the table\n * nodes. Per-schema metadata is carried on the typed `nativeEnumTypeNames`\n * field, not an annotations bag.\n */\nexport class PostgresNamespaceSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.namespace;\n  readonly schemaName: string;\n  readonly tables: Readonly<Record<string, PostgresTableSchemaNode>>;\n  readonly nativeEnumTypeNames: readonly string[];\n\n  constructor(input: PostgresNamespaceSchemaNodeInput) {\n    super();\n    this.schemaName = input.schemaName;\n    this.tables = Object.freeze({ ...input.tables });\n    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.schemaName;\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return Object.values(this.tables);\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresNamespaceSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.namespace;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresNamespaceSchemaNode {\n    if (!PostgresNamespaceSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresNamespaceSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport type { RlsPolicyOperation } from '../postgres-rls-policy';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresPolicySchemaNodeInput {\n  /** Full wire name: `<prefix>_<8hex>`. */\n  readonly name: string;\n  /** User-supplied prefix (the part before the `_<8hex>` suffix). */\n  readonly prefix: string;\n  /** Name of the table this policy attaches to, by name within the same schema. */\n  readonly tableName: string;\n  /** Namespace coordinate (schema name). */\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  /** Sorted role names rendered in `TO <roles>`. */\n  readonly roles: readonly string[];\n  /** USING predicate SQL string, if present. */\n  readonly using?: string;\n  /** WITH CHECK predicate SQL string, if present. */\n  readonly withCheck?: string;\n  /** `true` = `AS PERMISSIVE`, `false` = `AS RESTRICTIVE`. */\n  readonly permissive: boolean;\n}\n\n/**\n * Schema-diff leaf node for a Postgres row-level security policy.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRlsPolicy` contract entities / introspected rows.\n *\n * `id` is the wire name (`<prefix>_<sha256(body)[0..8]>`), so name-equality is\n * body-equality. `isEqualTo` compares names only — never byte-compare predicate\n * bodies, because Postgres reprints them.\n */\nexport class PostgresPolicySchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.policy;\n  readonly name: string;\n  readonly prefix: string;\n  readonly tableName: string;\n  readonly namespaceId: string;\n  readonly operation: RlsPolicyOperation;\n  readonly roles: readonly string[];\n  declare readonly using?: string;\n  declare readonly withCheck?: string;\n  readonly permissive: boolean;\n\n  constructor(input: PostgresPolicySchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.prefix = input.prefix;\n    this.tableName = input.tableName;\n    this.namespaceId = input.namespaceId;\n    this.operation = input.operation;\n    this.roles = Object.freeze([...input.roles]);\n    if (input.using !== undefined) this.using = input.using;\n    if (input.withCheck !== undefined) this.withCheck = input.withCheck;\n    this.permissive = input.permissive;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-policy kinds'\n    >(other);\n    PostgresPolicySchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresPolicySchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.policy;\n  }\n\n  static assert(node: SqlSchemaIRNode | undefined): asserts node is PostgresPolicySchemaNode {\n    if (node === undefined || !PostgresPolicySchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresPolicySchemaNode but got nodeKind=${node?.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport { SqlSchemaIRNode } from '@prisma-next/sql-schema-ir/types';\nimport { blindCast } from '@prisma-next/utils/casts';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresRoleSchemaNodeInput {\n  readonly name: string;\n  /**\n   * Namespace coordinate. Roles are cluster-scoped; callers pass\n   * `UNBOUND_NAMESPACE_ID` from `@prisma-next/framework-components/ir`.\n   */\n  readonly namespaceId: string;\n}\n\n/**\n * Schema-diff leaf node for a Postgres database role.\n *\n * This is a derived, transient node walked by the differ — it is NEVER serialized.\n * Built by project-from-contract and project-from-database from their respective\n * `PostgresRole` contract entities / introspected rows.\n *\n * Roles are cluster-scoped, so `id` is the role name alone. `isEqualTo` compares\n * names — name-equality is role-equality for cluster-scoped objects.\n */\nexport class PostgresRoleSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.role;\n  readonly name: string;\n  readonly namespaceId: string;\n\n  constructor(input: PostgresRoleSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.namespaceId = input.namespaceId;\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  children(): readonly DiffableNode[] {\n    return [];\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    const node = blindCast<\n      SqlSchemaIRNode,\n      'every diff-tree node the differ pairs is a SqlSchemaIRNode; the guard rejects non-role kinds'\n    >(other);\n    PostgresRoleSchemaNode.assert(node);\n    return this.id === node.id;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresRoleSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.role;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresRoleSchemaNode {\n    if (!PostgresRoleSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresRoleSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n","import type { DiffableNode } from '@prisma-next/framework-components/control';\nimport { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  PrimaryKey,\n  type SqlAnnotations,\n  SqlCheckConstraintIR,\n  SqlColumnIR,\n  SqlForeignKeyIR,\n  SqlIndexIR,\n  SqlSchemaIRNode,\n  type SqlTableIRInput,\n  SqlUniqueIR,\n} from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresPolicySchemaNode } from './postgres-policy-schema-node';\nimport { PostgresSchemaNodeKind } from './schema-node-kinds';\n\nexport interface PostgresTableSchemaNodeInput extends SqlTableIRInput {\n  readonly policies?: readonly PostgresPolicySchemaNode[];\n}\n\n/**\n * Postgres-specific table schema-diff node. Carries all `SqlTableIR` fields\n * plus `policies`, and implements `DiffableNode` so the table instance is\n * directly the diff-tree node — no separate wrapper needed.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlTableIR` because\n * `SqlTableIR` calls `freezeNode` in its own constructor, which prevents\n * subclass field initialisation.\n *\n * `id` is the table name. `children()` returns the policy nodes on this table.\n * `isEqualTo` is identity — two table nodes are equal iff their ids (names)\n * match. Columns are not compared here; they become child nodes later.\n */\nexport class PostgresTableSchemaNode extends SqlSchemaIRNode implements DiffableNode {\n  override readonly nodeKind = PostgresSchemaNodeKind.table;\n  readonly name: string;\n  readonly columns: Readonly<Record<string, SqlColumnIR>>;\n  readonly foreignKeys: ReadonlyArray<SqlForeignKeyIR>;\n  readonly uniques: ReadonlyArray<SqlUniqueIR>;\n  readonly indexes: ReadonlyArray<SqlIndexIR>;\n  declare readonly primaryKey?: PrimaryKey;\n  declare readonly annotations?: SqlAnnotations;\n  declare readonly checks?: ReadonlyArray<SqlCheckConstraintIR>;\n  readonly policies: readonly PostgresPolicySchemaNode[];\n\n  constructor(input: PostgresTableSchemaNodeInput) {\n    super();\n    this.name = input.name;\n    this.columns = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.columns).map(([key, col]) => [\n          key,\n          col instanceof SqlColumnIR ? col : new SqlColumnIR(col),\n        ]),\n      ),\n    );\n    this.foreignKeys = Object.freeze(\n      input.foreignKeys.map((fk) => (fk instanceof SqlForeignKeyIR ? fk : new SqlForeignKeyIR(fk))),\n    );\n    this.uniques = Object.freeze(\n      input.uniques.map((u) => (u instanceof SqlUniqueIR ? u : new SqlUniqueIR(u))),\n    );\n    this.indexes = Object.freeze(\n      input.indexes.map((i) => (i instanceof SqlIndexIR ? i : new SqlIndexIR(i))),\n    );\n    if (input.primaryKey !== undefined) {\n      this.primaryKey =\n        input.primaryKey instanceof PrimaryKey\n          ? input.primaryKey\n          : new PrimaryKey(input.primaryKey);\n    }\n    if (input.annotations !== undefined) this.annotations = input.annotations;\n    if (input.checks !== undefined && input.checks.length > 0) {\n      this.checks = Object.freeze(\n        input.checks.map((c) =>\n          c instanceof SqlCheckConstraintIR ? c : new SqlCheckConstraintIR(c),\n        ),\n      );\n    }\n    this.policies = Object.freeze([...(input.policies ?? [])]);\n    freezeNode(this);\n  }\n\n  get id(): string {\n    return this.name;\n  }\n\n  isEqualTo(other: DiffableNode): boolean {\n    return this.id === other.id;\n  }\n\n  children(): readonly DiffableNode[] {\n    return this.policies;\n  }\n\n  static is(node: SqlSchemaIRNode): node is PostgresTableSchemaNode {\n    return node.nodeKind === PostgresSchemaNodeKind.table;\n  }\n\n  static assert(node: SqlSchemaIRNode): asserts node is PostgresTableSchemaNode {\n    if (!PostgresTableSchemaNode.is(node)) {\n      throw new Error(\n        `Expected a PostgresTableSchemaNode but got nodeKind=${node.nodeKind ?? 'undefined'}`,\n      );\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/resolve-ddl-schema-CL1RR1mx.mjs

@@ -0,0 +1,20 @@
+import { r as isPostgresSchema } from "./postgres-schema-BLIHBEfX.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+//#region src/core/migrations/resolve-ddl-schema.ts
+/**
+* Given the contract's storage and a namespace id, returns the live Postgres
+* DDL schema name that namespace maps to. A named Postgres namespace dispatches
+* to its `ddlSchemaName(storage)`; the unbound sentinel resolves to `public`
+* (the search-path default for offline planning); a bare object payload (used
+* by some tests) falls back to the namespace id itself.
+*/
+function resolveDdlSchemaForNamespaceStorage(storage, namespaceId) {
+	if (namespaceId === UNBOUND_NAMESPACE_ID) return "public";
+	const namespace = storage.namespaces[namespaceId];
+	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
+	return namespaceId;
+}
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage as t };
+
+//# sourceMappingURL=resolve-ddl-schema-CL1RR1mx.mjs.map

package/dist/resolve-ddl-schema-CL1RR1mx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-ddl-schema-CL1RR1mx.mjs","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { isPostgresSchema } from '../postgres-schema';\n\n/**\n * Given the contract's storage and a namespace id, returns the live Postgres\n * DDL schema name that namespace maps to. A named Postgres namespace dispatches\n * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to `public`\n * (the search-path default for offline planning); a bare object payload (used\n * by some tests) falls back to the namespace id itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return 'public';\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;AAWA,SAAgB,oCACd,SACA,aACQ;CACR,IAAI,gBAAgB,sBAClB,OAAO;CAET,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
 import { t as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-runtime-UwYdV8fD.mjs";
-import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-CoRZewAp.mjs";
+import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-BegduLr6.mjs";
 //#region src/exports/runtime.ts
 /**
 * Target-postgres deliberately does NOT import `SqlRuntimeTargetDescriptor` from `@prisma-next/sql-runtime`. The target package is a control-plane residence and must not pull the SQL execution-plane package into its dependency closure. The runtime descriptor here is shaped to satisfy the framework's `RuntimeTargetDescriptor` plus the structural `SqlStaticContributions` (`codecs:` returning a descriptor list) that

package/dist/schema-ir-annotations.d.mts

@@ -1,8 +1,14 @@
 import { SqlStorage } from "@prisma-next/sql-contract/types";
-import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
 
-//#region src/core/schema-ir/postgres-schema-ir-annotations.d.ts
-declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string, schemaIr?: SqlSchemaIR): string;
+//#region src/core/migrations/resolve-ddl-schema.d.ts
+/**
+ * Given the contract's storage and a namespace id, returns the live Postgres
+ * DDL schema name that namespace maps to. A named Postgres namespace dispatches
+ * to its `ddlSchemaName(storage)`; the unbound sentinel resolves to `public`
+ * (the search-path default for offline planning); a bare object payload (used
+ * by some tests) falls back to the namespace id itself.
+ */
+declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string): string;
 //#endregion
 export { resolveDdlSchemaForNamespaceStorage };
 //# sourceMappingURL=schema-ir-annotations.d.mts.map

package/dist/schema-ir-annotations.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-ir-annotations.d.mts","names":[],"sources":["../src/core/schema-ir/postgres-schema-ir-annotations.ts"],"mappings":";;;;iBAMgB,mCAAA,CACd,OAAA,EAAS,UAAA,EACT,WAAA,UACA,QAAA,GAAW,WAAW"}
+{"version":3,"file":"schema-ir-annotations.d.mts","names":[],"sources":["../src/core/migrations/resolve-ddl-schema.ts"],"mappings":";;;;;AAWA;;;;;iBAAgB,mCAAA,CACd,OAAA,EAAS,UAAU,EACnB,WAAA"}

package/dist/schema-ir-annotations.mjs

@@ -1,2 +1,2 @@
-import { t as resolveDdlSchemaForNamespaceStorage } from "./postgres-schema-ir-annotations-BbDSiwx2.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-CL1RR1mx.mjs";
 export { resolveDdlSchemaForNamespaceStorage };

package/dist/types.d.mts

@@ -1,5 +1,5 @@
-import { n as PostgresRlsPolicyInput, r as RlsPolicyOperation, t as PostgresRlsPolicy } from "./postgres-rls-policy-12wAEQhs.mjs";
+import { n as PostgresRlsPolicyInput, r as RlsPolicyOperation, t as PostgresRlsPolicy } from "./postgres-rls-policy--CSddvMR.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
-import { a as postgresCreateNamespace, i as isPostgresSchema, n as PostgresSchema, o as PostgresRole, r as PostgresUnboundSchema, s as PostgresRoleInput, t as PostgresContract } from "./postgres-schema-DJUEkWg-.mjs";
-import { a as isPostgresSchemaIR, c as isPostgresTableIR, i as ensurePostgresSchemaIR, n as PostgresSchemaIRInput, o as PostgresTableIR, r as assertPostgresSchemaIR, s as PostgresTableIRInput, t as PostgresSchemaIR } from "./postgres-schema-ir-BJl_a3J7.mjs";
-export { type PostgresColumnDefault, type PostgresContract, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresSchema, PostgresSchemaIR, type PostgresSchemaIRInput, PostgresTableIR, type PostgresTableIRInput, PostgresUnboundSchema, type RlsPolicyOperation, assertPostgresSchemaIR, ensurePostgresSchemaIR, isPostgresSchema, isPostgresSchemaIR, isPostgresTableIR, postgresCreateNamespace };
+import { a as postgresCreateNamespace, i as isPostgresSchema, n as PostgresSchema, o as PostgresRole, r as PostgresUnboundSchema, s as PostgresRoleInput, t as PostgresContract } from "./postgres-schema-BywoeKlt.mjs";
+import { a as PostgresNamespaceSchemaNode, c as PostgresTableSchemaNodeInput, i as PostgresRoleSchemaNodeInput, l as PostgresPolicySchemaNode, n as PostgresDatabaseSchemaNodeInput, o as PostgresNamespaceSchemaNodeInput, r as PostgresRoleSchemaNode, s as PostgresTableSchemaNode, t as PostgresDatabaseSchemaNode, u as PostgresPolicySchemaNodeInput } from "./postgres-database-schema-node-os8ogEap.mjs";
+export { type PostgresColumnDefault, type PostgresContract, PostgresDatabaseSchemaNode, type PostgresDatabaseSchemaNodeInput, PostgresNamespaceSchemaNode, type PostgresNamespaceSchemaNodeInput, PostgresPolicySchemaNode, type PostgresPolicySchemaNodeInput, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresRoleSchemaNode, type PostgresRoleSchemaNodeInput, PostgresSchema, PostgresTableSchemaNode, type PostgresTableSchemaNodeInput, PostgresUnboundSchema, type RlsPolicyOperation, isPostgresSchema, postgresCreateNamespace };

package/dist/types.mjs

@@ -1,3 +1,3 @@
-import { c as PostgresRole, i as postgresCreateNamespace, l as PostgresRlsPolicy, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-DLcc3W2-.mjs";
-import { a as PostgresTableIR, i as isPostgresSchemaIR, n as assertPostgresSchemaIR, o as isPostgresTableIR, r as ensurePostgresSchemaIR, t as PostgresSchemaIR } from "./postgres-schema-ir-I_FiUndw.mjs";
-export { PostgresRlsPolicy, PostgresRole, PostgresSchema, PostgresSchemaIR, PostgresTableIR, PostgresUnboundSchema, assertPostgresSchemaIR, ensurePostgresSchemaIR, isPostgresSchema, isPostgresSchemaIR, isPostgresTableIR, postgresCreateNamespace };
+import { d as PostgresRlsPolicy, i as postgresCreateNamespace, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema, u as PostgresRole } from "./postgres-schema-BLIHBEfX.mjs";
+import { a as PostgresDatabaseSchemaNode, i as PostgresNamespaceSchemaNode, n as PostgresRoleSchemaNode, r as PostgresPolicySchemaNode, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-1nNc8XDT.mjs";
+export { PostgresDatabaseSchemaNode, PostgresNamespaceSchemaNode, PostgresPolicySchemaNode, PostgresRlsPolicy, PostgresRole, PostgresRoleSchemaNode, PostgresSchema, PostgresTableSchemaNode, PostgresUnboundSchema, isPostgresSchema, postgresCreateNamespace };

package/package.json

@@ -1,34 +1,35 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.14.0-dev.39",
+  "version": "0.14.0-dev.40",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.14.0-dev.39",
-    "@prisma-next/contract": "0.14.0-dev.39",
-    "@prisma-next/errors": "0.14.0-dev.39",
-    "@prisma-next/family-sql": "0.14.0-dev.39",
-    "@prisma-next/framework-components": "0.14.0-dev.39",
-    "@prisma-next/migration-tools": "0.14.0-dev.39",
-    "@prisma-next/ts-render": "0.14.0-dev.39",
-    "@prisma-next/sql-contract": "0.14.0-dev.39",
-    "@prisma-next/sql-errors": "0.14.0-dev.39",
-    "@prisma-next/sql-operations": "0.14.0-dev.39",
-    "@prisma-next/sql-relational-core": "0.14.0-dev.39",
-    "@prisma-next/sql-schema-ir": "0.14.0-dev.39",
-    "@prisma-next/utils": "0.14.0-dev.39",
+    "@prisma-next/cli": "0.14.0-dev.40",
+    "@prisma-next/contract": "0.14.0-dev.40",
+    "@prisma-next/errors": "0.14.0-dev.40",
+    "@prisma-next/family-sql": "0.14.0-dev.40",
+    "@prisma-next/framework-components": "0.14.0-dev.40",
+    "@prisma-next/migration-tools": "0.14.0-dev.40",
+    "@prisma-next/sql-contract": "0.14.0-dev.40",
+    "@prisma-next/sql-errors": "0.14.0-dev.40",
+    "@prisma-next/sql-operations": "0.14.0-dev.40",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.40",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.40",
+    "@prisma-next/ts-render": "0.14.0-dev.40",
+    "@prisma-next/utils": "0.14.0-dev.40",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/psl-parser": "0.14.0-dev.39",
-    "@prisma-next/sql-contract-psl": "0.14.0-dev.39",
-    "@prisma-next/test-utils": "0.14.0-dev.39",
-    "@prisma-next/tsconfig": "0.14.0-dev.39",
-    "@prisma-next/tsdown": "0.14.0-dev.39",
+    "@prisma-next/psl-parser": "0.14.0-dev.40",
+    "@prisma-next/psl-printer": "0.14.0-dev.40",
+    "@prisma-next/sql-contract-psl": "0.14.0-dev.40",
+    "@prisma-next/test-utils": "0.14.0-dev.40",
+    "@prisma-next/tsconfig": "0.14.0-dev.40",
+    "@prisma-next/tsdown": "0.14.0-dev.40",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"

package/src/core/authoring.ts

@@ -7,10 +7,10 @@ import type {
   AuthoringTypeNamespace,
   PslExtensionBlock,
 } from '@prisma-next/framework-components/authoring';
+import { PostgresRlsPolicy } from './postgres-rls-policy';
+import { PostgresRole, type PostgresRoleInput } from './postgres-role';
 import { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';
 import { computeContentHash, normalizePredicate } from './rls/canonicalize';
-import { PostgresRlsPolicy } from './schema-ir/postgres-rls-policy';
-import { PostgresRole, type PostgresRoleInput } from './schema-ir/postgres-role';
 
 export const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;
 

package/src/core/entity-kinds.ts

@@ -1,7 +1,7 @@
 import type { EntityKindDescriptor } from '@prisma-next/framework-components/ir';
+import { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './postgres-rls-policy';
+import { PostgresRole, type PostgresRoleInput } from './postgres-role';
 import { PostgresRlsPolicySchema, PostgresRoleSchema } from './postgres-validators';
-import { PostgresRlsPolicy, type PostgresRlsPolicyInput } from './schema-ir/postgres-rls-policy';
-import { PostgresRole, type PostgresRoleInput } from './schema-ir/postgres-role';
 
 export const policyEntityKind: EntityKindDescriptor<PostgresRlsPolicyInput, PostgresRlsPolicy> = {
   kind: 'policy',

package/src/core/migrations/contract-to-postgres-database-schema-node.ts

@@ -0,0 +1,125 @@
+import type { ContractToSchemaIROptions } from '@prisma-next/family-sql/control';
+import { contractNamespaceToSchemaIR } from '@prisma-next/family-sql/control';
+import { ifDefined } from '@prisma-next/utils/defined';
+import type { PostgresRlsPolicy } from '../postgres-rls-policy';
+import type { PostgresContract } from '../postgres-schema';
+import { isPostgresSchema } from '../postgres-schema';
+import { PostgresDatabaseSchemaNode } from '../schema-ir/postgres-database-schema-node';
+import { PostgresNamespaceSchemaNode } from '../schema-ir/postgres-namespace-schema-node';
+import { PostgresPolicySchemaNode } from '../schema-ir/postgres-policy-schema-node';
+import { PostgresRoleSchemaNode } from '../schema-ir/postgres-role-schema-node';
+import { PostgresTableSchemaNode } from '../schema-ir/postgres-table-schema-node';
+import { resolveDdlSchemaForNamespaceStorage } from './resolve-ddl-schema';
+
+function toPolicyNode(policy: PostgresRlsPolicy, namespaceId: string): PostgresPolicySchemaNode {
+  return new PostgresPolicySchemaNode({
+    name: policy.name,
+    prefix: policy.prefix,
+    tableName: policy.tableName,
+    namespaceId,
+    operation: policy.operation,
+    roles: [...policy.roles],
+    ...ifDefined('using', policy.using),
+    ...ifDefined('withCheck', policy.withCheck),
+    permissive: policy.permissive,
+  });
+}
+
+/**
+ * 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.
+ */
+export function contractToPostgresDatabaseSchemaNode(
+  contract: PostgresContract | null,
+  options: ContractToSchemaIROptions,
+): PostgresDatabaseSchemaNode {
+  if (contract === null) {
+    return new PostgresDatabaseSchemaNode({
+      namespaces: {},
+      roles: [],
+      existingSchemas: [],
+      pgVersion: '',
+    });
+  }
+
+  const namespaces: Record<string, PostgresNamespaceSchemaNode> = {};
+  const roles: PostgresRoleSchemaNode[] = [];
+  const ownedSchemas: string[] = [];
+
+  for (const ns of Object.values(contract.storage.namespaces)) {
+    if (!isPostgresSchema(ns)) continue;
+    const ddlSchema = resolveDdlSchemaForNamespaceStorage(contract.storage, ns.id);
+    ownedSchemas.push(ddlSchema);
+
+    // Convert only THIS namespace's tables (passing the full storage for
+    // type/value-set/enum resolution that spans namespaces), so the same table
+    // name can exist in two schemas without colliding in a bare-keyed record.
+    const sqlTables = contractNamespaceToSchemaIR(contract.storage, ns.id, options).tables;
+
+    const policiesByTable = new Map<string, PostgresPolicySchemaNode[]>();
+    for (const policy of Object.values(ns.policy)) {
+      const list = policiesByTable.get(policy.tableName) ?? [];
+      list.push(toPolicyNode(policy, ddlSchema));
+      policiesByTable.set(policy.tableName, list);
+    }
+
+    const tables: Record<string, PostgresTableSchemaNode> = {};
+    for (const tableName of Object.keys(ns.table)) {
+      const sqlTable = sqlTables[tableName];
+      if (sqlTable === undefined) continue;
+      tables[tableName] = new PostgresTableSchemaNode({
+        name: sqlTable.name,
+        columns: sqlTable.columns,
+        foreignKeys: sqlTable.foreignKeys,
+        uniques: sqlTable.uniques,
+        indexes: sqlTable.indexes,
+        ...ifDefined('primaryKey', sqlTable.primaryKey),
+        ...ifDefined('annotations', sqlTable.annotations),
+        ...ifDefined('checks', sqlTable.checks),
+        policies: policiesByTable.get(tableName) ?? [],
+      });
+    }
+
+    for (const [tableName, tablePolicies] of policiesByTable) {
+      if (!(tableName in tables)) {
+        const policyName = tablePolicies[0]?.name ?? '(unknown)';
+        throw new Error(
+          `contract-to-postgres-database-schema-node: policy "${policyName}" references table "${tableName}" not present in namespace "${ddlSchema}"`,
+        );
+      }
+    }
+
+    namespaces[ddlSchema] = new PostgresNamespaceSchemaNode({
+      schemaName: ddlSchema,
+      tables,
+      nativeEnumTypeNames: [],
+    });
+
+    for (const role of Object.values(ns.role)) {
+      roles.push(new PostgresRoleSchemaNode({ name: role.name, namespaceId: role.namespaceId }));
+    }
+  }
+
+  return new PostgresDatabaseSchemaNode({
+    namespaces,
+    roles,
+    existingSchemas: ownedSchemas,
+    pgVersion: '',
+  });
+}