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

package/dist/postgres-schema-D0h4lsw2.d.mts

@@ -0,0 +1,158 @@
+import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy-D_z1osEq.mjs";
+import { t as PostgresRole } from "./postgres-role-_CCuyPCQ.mjs";
+import { NamespaceBase } from "@prisma-next/framework-components/ir";
+import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
+import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
+
+//#region src/core/postgres-schema.d.ts
+type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
+  readonly role?: Readonly<Record<string, PostgresRole>>;
+};
+interface PostgresSchemaInput {
+  readonly id: string;
+  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+/**
+ * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
+ * SCHEMA …`). Each Postgres `SqlStorage` carries a
+ * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
+ * the Postgres PSL interpreter from `namespace { … }` AST buckets.
+ *
+ * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
+ * emission is the rendering seam: DDL / SQL emission asks the namespace
+ * for its qualifier (`"<schema>"`) or for a qualified table name
+ * (`"<schema>"."<table>"`) and consumes the result polymorphically.
+ * The unbound singleton below overrides these methods to elide the
+ * prefix entirely — call sites stay polymorphic and never branch on
+ * `id === UNBOUND_NAMESPACE_ID`.
+ */
+declare class PostgresSchema extends NamespaceBase {
+  /**
+   * Stable singleton reference for the late-bound slot. Materialised
+   * lazily below the singleton subclass declaration so the static
+   * initialiser sees the subclass before assigning. Consumers always
+   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`
+   * — same identity).
+   */
+  static unbound: PostgresUnboundSchema;
+  readonly kind: 'schema';
+  readonly id: string;
+  readonly entries: PostgresNamespaceEntries;
+  constructor(input: PostgresSchemaInput);
+  get table(): Readonly<Record<string, StorageTable>>;
+  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
+  get policy(): Readonly<Record<string, PostgresRlsPolicy>>;
+  get role(): Readonly<Record<string, PostgresRole>>;
+  /**
+   * The bare schema qualifier as it would appear in a rendered SQL
+   * fragment (already quoted). The unbound-schema singleton overrides
+   * this to return `''`.
+   */
+  qualifier(): string;
+  /**
+   * Qualify a table name with the schema prefix
+   * (`"<schema>"."<table>"`). The unbound-schema singleton overrides
+   * this to emit just `"<table>"` so the resolved DDL is unqualified
+   * and `search_path` decides where the object lands at runtime.
+   */
+  qualifyTable(tableName: string): string;
+  /**
+   * Render a SQL string-literal containing the qualified-name form
+   * suitable for `to_regclass(...)` arguments (e.g. `'"public"."user"'`).
+   * The unbound singleton overrides this to elide the schema prefix
+   * (`'"user"'`) so `search_path` resolves the object at runtime.
+   */
+  regclassLiteral(name: string): string;
+  /**
+   * Render a SQL expression that evaluates to this namespace's schema
+   * name at runtime, ready to drop into a `WHERE table_schema = …` /
+   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL
+   * literal (`'public'`); the unbound singleton overrides this to emit
+   * `current_schema()` so catalog queries match whichever schema the
+   * connection's `search_path` resolved at runtime.
+   */
+  schemaSqlExpression(): string;
+  /**
+   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
+   * builder-built catalog check compares `n.nspname` / `table_schema`
+   * against. Named schemas bind the schema name as a text parameter; the
+   * unbound singleton overrides this to the opaque `current_schema()`
+   * expression so the live connection's `search_path` decides at runtime.
+   */
+  schemaFilterExpression(): CfExpr;
+  /**
+   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
+   * builder-built check uses to address a user table in this namespace.
+   * Named schemas qualify (`"schema"."table"`); the unbound singleton
+   * overrides this to leave the table unqualified so `search_path`
+   * resolves it at runtime.
+   */
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
+  /**
+   * The bare schema name a DDL planner should target when emitting
+   * statements that need to identify this namespace in the live
+   * database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
+   * catalog filters, planner conflict lookups). Named schemas resolve
+   * to their own id. The `PostgresUnboundSchema` singleton inherits
+   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
+   * through `qualifyTableName` route through the polymorphic
+   * `PostgresUnboundSchema` overrides and produce unqualified
+   * (search-path-resolved) output automatically.
+   */
+  ddlSchemaName(_storage: SqlStorage): string;
+}
+/**
+ * Singleton subclass for the reserved sentinel namespace id
+ * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding
+ * the connection's `search_path` resolves at runtime. Overrides
+ * qualifier emission to elide the schema prefix; call sites that consume
+ * `qualifier()` / `qualifyTable()` get unqualified output without
+ * branching on the namespace id.
+ *
+ * This is the target-side materialization of "the framework provides
+ * affordances; targets implement specifics": the framework names the
+ * sentinel; Postgres decides what late-bound means here (the table
+ * name, naked — the schema is supplied by the live connection's
+ * `search_path`).
+ *
+ * `ddlSchemaName` is inherited from `PostgresSchema` and returns
+ * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
+ * route through the polymorphic factory and produce unqualified output
+ * automatically.
+ */
+declare class PostgresUnboundSchema extends PostgresSchema {
+  static readonly instance: PostgresUnboundSchema;
+  constructor(input?: PostgresSchemaInput);
+  qualifier(): string;
+  qualifyTable(tableName: string): string;
+  schemaSqlExpression(): string;
+  schemaFilterExpression(): CfExpr;
+  tableSource(tableName: string, alias?: string): PostgresTableSource;
+}
+/**
+ * Narrow an arbitrary namespace (or `undefined`) to `PostgresSchema`
+ * so callers can dispatch to the polymorphic emission methods without
+ * branching at the call site. Uses the structural `kind` discriminator
+ * (`'schema'`) rather than `instanceof` so the check survives realm /
+ * bundle / hot-reload boundaries — matching the rest of the IR's
+ * narrowing convention. `PostgresUnboundSchema` passes through because
+ * it inherits the same `kind: 'schema'` from `PostgresSchema`.
+ */
+declare function isPostgresSchema(ns: unknown): ns is PostgresSchema;
+/**
+ * Target-supplied `Namespace` factory the Postgres target plumbs
+ * through `defineContract({ createNamespace })` and the SQL PSL
+ * interpreter. Returns the unbound singleton for the framework
+ * sentinel and a fresh `PostgresSchema` for any other coordinate.
+ *
+ * The factory has no per-call state — every named id deterministically
+ * maps to a distinct schema instance — so callers can pass it through
+ * by reference and trust the resulting `SqlStorage.namespaces` map to
+ * be value-stable for a given input set.
+ */
+declare function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema;
+//#endregion
+export { postgresCreateNamespace as i, PostgresUnboundSchema as n, isPostgresSchema as r, PostgresSchema as t };
+//# sourceMappingURL=postgres-schema-D0h4lsw2.d.mts.map

package/dist/postgres-schema-D0h4lsw2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-D0h4lsw2.d.mts","names":[],"sources":["../src/core/postgres-schema.ts"],"mappings":";;;;;;;;KAwBY,wBAAA,GAA2B,mBAAA;EAAA,SAC5B,MAAA,GAAS,QAAA,CAAS,MAAA,SAAe,iBAAA;EAAA,SACjC,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,YAAA;AAAA;AAAA,UAGzB,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA;AAAA;;;;;;;;;;;;;;;cAiBxC,cAAA,SAAuB,aAAA;EAtBkB;AAAA;AAGtD;;;;;EAHsD,OA8B7C,OAAA,EAAS,qBAAA;EAAA,SAEC,IAAA;EAAA,SACR,EAAA;EAAA,SACA,OAAA,EAAS,wBAAA;cAEN,KAAA,EAAO,mBAAA;EAAA,IAgCf,KAAA,IAAS,QAAA,CAAS,MAAA,SAAe,YAAA;EAAA,IAIjC,QAAA,IAAY,QAAA,CAAS,MAAA,SAAe,eAAA;EAAA,IAIpC,MAAA,IAAU,QAAA,CAAS,MAAA,SAAe,iBAAA;EAAA,IAIlC,IAAA,IAAQ,QAAA,CAAS,MAAA,SAAe,YAAA;EA3Ee;;AAAM;AAiB3D;;EAmEE,SAAA;EA3DgB;;;;;;EAqEhB,YAAA,CAAa,SAAA;EA3BY;;;;;;EAqCzB,eAAA,CAAgB,IAAA;EA7BJ;;;;;;;;EAyCZ,mBAAA;EA3FgB;;;;;;;EAsGhB,sBAAA,IAA0B,MAAA;EAhEtB;;;;;;;EA2EJ,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;EAnE5C;;;;;;;;;;;EAsFJ,aAAA,CAAc,QAAA,EAAU,UAAA;AAAA;;;;;;;;;;;;AAAU;AAwBpC;;;;;;;cAAa,qBAAA,SAA8B,cAAA;EAAA,gBACzB,QAAA,EAAU,qBAAA;cAEd,KAAA,GAAQ,mBAAA;EAIX,SAAA;EAIA,YAAA,CAAa,SAAA;EAIb,mBAAA;EAIA,sBAAA,IAA0B,MAAA;EAI1B,WAAA,CAAY,SAAA,UAAmB,KAAA,YAAiB,mBAAA;AAAA;;;;;;;;;;iBAmB3C,gBAAA,CAAiB,EAAA,YAAc,EAAA,IAAM,cAAc;;AAnBW;AAmB9E;;;;;;;;AAAmE;iBAenD,uBAAA,CAAwB,KAAA,EAAO,uBAAA,GAA0B,cAAc"}

package/dist/postgres-schema-ir-BF0X8jit.mjs

@@ -0,0 +1,66 @@
+import { freezeNode } from "@prisma-next/framework-components/ir";
+import { SqlSchemaIRNode, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/postgres-schema-ir.ts
+/**
+* Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`
+* (same `tables` + optional `annotations` fields) and adds typed fields for
+* data the postgres adapter collects during introspection.
+*
+* Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because
+* `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents
+* subclass field initialisation. `PostgresSchemaIR` replicates the minimal
+* `SqlSchemaIR` structure and freezes itself at the end of its own
+* constructor.
+*
+* RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on
+* this class — no `Reflect.get`, no untyped annotation bag access. The
+* `annotations.pg` bag is populated with only the subset the family layer
+* reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer
+* PSL inference and namespace verification continue to work without knowing
+* about RLS.
+*
+* Nothing RLS-specific leaks into the sql-family layer.
+*/
+var PostgresSchemaIR = class extends SqlSchemaIRNode {
+	nodeTarget = "postgres";
+	tables;
+	pgSchemaName;
+	pgVersion;
+	rlsPolicies;
+	roles;
+	existingSchemas;
+	nativeEnumTypeNames;
+	constructor(input) {
+		super();
+		this.tables = Object.freeze(Object.fromEntries(Object.entries(input.tables).map(([key, t]) => [key, t instanceof SqlTableIR ? t : new SqlTableIR(t)])));
+		this.pgSchemaName = input.pgSchemaName;
+		this.pgVersion = input.pgVersion;
+		this.rlsPolicies = Object.freeze([...input.rlsPolicies]);
+		this.roles = Object.freeze([...input.roles]);
+		this.existingSchemas = Object.freeze([...input.existingSchemas]);
+		this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);
+		this.annotations = { pg: {
+			schema: input.pgSchemaName,
+			...input.nativeEnumTypeNames.length > 0 && { nativeEnumTypeNames: input.nativeEnumTypeNames },
+			...input.existingSchemas.length > 0 && { existingSchemas: input.existingSchemas }
+		} };
+		freezeNode(this);
+	}
+};
+/**
+* Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`
+* discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field
+* (a plain class-field initializer), so it survives the `{ ...schema, tables }`
+* spread the multi-space verify path (`projectSchemaToSpace`) produces — that
+* projected object is not a class instance but retains every enumerable own
+* property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable
+* here: it is shared by every SQL schema-IR node and is non-enumerable (dropped
+* by the spread).
+*/
+function isPostgresSchemaIR(schema) {
+	return schema.nodeTarget === "postgres";
+}
+//#endregion
+export { isPostgresSchemaIR as n, PostgresSchemaIR as t };
+
+//# sourceMappingURL=postgres-schema-ir-BF0X8jit.mjs.map

package/dist/postgres-schema-ir-BF0X8jit.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-BF0X8jit.mjs","names":[],"sources":["../src/core/postgres-schema-ir.ts"],"sourcesContent":["import { freezeNode } from '@prisma-next/framework-components/ir';\nimport {\n  type SqlAnnotations,\n  type SqlSchemaIR,\n  SqlSchemaIRNode,\n  type SqlSchemaTarget,\n  SqlTableIR,\n  type SqlTableIRInput,\n} from '@prisma-next/sql-schema-ir/types';\nimport type { PostgresRlsPolicy } from './postgres-rls-policy';\nimport type { PostgresRole } from './postgres-role';\n\nexport interface PostgresSchemaIRInput {\n  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\n  readonly rlsPolicies: readonly PostgresRlsPolicy[];\n  readonly roles: readonly PostgresRole[];\n  readonly existingSchemas: readonly string[];\n  readonly nativeEnumTypeNames: readonly string[];\n}\n\n/**\n * Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`\n * (same `tables` + optional `annotations` fields) and adds typed fields for\n * data the postgres adapter collects during introspection.\n *\n * Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because\n * `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents\n * subclass field initialisation. `PostgresSchemaIR` replicates the minimal\n * `SqlSchemaIR` structure and freezes itself at the end of its own\n * constructor.\n *\n * RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on\n * this class — no `Reflect.get`, no untyped annotation bag access. The\n * `annotations.pg` bag is populated with only the subset the family layer\n * reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer\n * PSL inference and namespace verification continue to work without knowing\n * about RLS.\n *\n * Nothing RLS-specific leaks into the sql-family layer.\n */\nexport class PostgresSchemaIR extends SqlSchemaIRNode {\n  readonly nodeTarget: SqlSchemaTarget = 'postgres';\n  readonly tables: Readonly<Record<string, SqlTableIR>>;\n  declare readonly annotations?: SqlAnnotations;\n  readonly pgSchemaName: string;\n  readonly pgVersion: string;\n  readonly rlsPolicies: readonly PostgresRlsPolicy[];\n  readonly roles: readonly PostgresRole[];\n  readonly existingSchemas: readonly string[];\n  readonly nativeEnumTypeNames: readonly string[];\n\n  constructor(input: PostgresSchemaIRInput) {\n    super();\n    this.tables = Object.freeze(\n      Object.fromEntries(\n        Object.entries(input.tables).map(([key, t]) => [\n          key,\n          t instanceof SqlTableIR ? t : new SqlTableIR(t),\n        ]),\n      ),\n    );\n    this.pgSchemaName = input.pgSchemaName;\n    this.pgVersion = input.pgVersion;\n    this.rlsPolicies = Object.freeze([...input.rlsPolicies]);\n    this.roles = Object.freeze([...input.roles]);\n    this.existingSchemas = Object.freeze([...input.existingSchemas]);\n    this.nativeEnumTypeNames = Object.freeze([...input.nativeEnumTypeNames]);\n    // Populate the annotations.pg bag with only the subset the family layer\n    // reads (nativeEnumTypeNames for PSL inference, existingSchemas for\n    // namespace presence checks). rlsPolicies and roles are NOT placed here\n    // — they are consumed directly via typed fields on this class.\n    this.annotations = {\n      pg: {\n        schema: input.pgSchemaName,\n        ...(input.nativeEnumTypeNames.length > 0 && {\n          nativeEnumTypeNames: input.nativeEnumTypeNames,\n        }),\n        ...(input.existingSchemas.length > 0 && {\n          existingSchemas: input.existingSchemas,\n        }),\n      },\n    };\n    freezeNode(this);\n  }\n}\n\n/**\n * Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`\n * discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field\n * (a plain class-field initializer), so it survives the `{ ...schema, tables }`\n * spread the multi-space verify path (`projectSchemaToSpace`) produces — that\n * projected object is not a class instance but retains every enumerable own\n * property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable\n * here: it is shared by every SQL schema-IR node and is non-enumerable (dropped\n * by the spread).\n */\nexport function isPostgresSchemaIR(schema: SqlSchemaIR): schema is PostgresSchemaIR {\n  return schema.nodeTarget === 'postgres';\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,mBAAb,cAAsC,gBAAgB;CACpD,aAAuC;CACvC;CAEA;CACA;CACA;CACA;CACA;CACA;CAEA,YAAY,OAA8B;EACxC,MAAM;EACN,KAAK,SAAS,OAAO,OACnB,OAAO,YACL,OAAO,QAAQ,MAAM,MAAM,CAAC,CAAC,KAAK,CAAC,KAAK,OAAO,CAC7C,KACA,aAAa,aAAa,IAAI,IAAI,WAAW,CAAC,CAChD,CAAC,CACH,CACF;EACA,KAAK,eAAe,MAAM;EAC1B,KAAK,YAAY,MAAM;EACvB,KAAK,cAAc,OAAO,OAAO,CAAC,GAAG,MAAM,WAAW,CAAC;EACvD,KAAK,QAAQ,OAAO,OAAO,CAAC,GAAG,MAAM,KAAK,CAAC;EAC3C,KAAK,kBAAkB,OAAO,OAAO,CAAC,GAAG,MAAM,eAAe,CAAC;EAC/D,KAAK,sBAAsB,OAAO,OAAO,CAAC,GAAG,MAAM,mBAAmB,CAAC;EAKvE,KAAK,cAAc,EACjB,IAAI;GACF,QAAQ,MAAM;GACd,GAAI,MAAM,oBAAoB,SAAS,KAAK,EAC1C,qBAAqB,MAAM,oBAC7B;GACA,GAAI,MAAM,gBAAgB,SAAS,KAAK,EACtC,iBAAiB,MAAM,gBACzB;EACF,EACF;EACA,WAAW,IAAI;CACjB;AACF;;;;;;;;;;;AAYA,SAAgB,mBAAmB,QAAiD;CAClF,OAAO,OAAO,eAAe;AAC/B"}

package/dist/postgres-schema-ir-BQ3RpZMz.d.mts

@@ -0,0 +1,60 @@
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy-D_z1osEq.mjs";
+import { t as PostgresRole } from "./postgres-role-_CCuyPCQ.mjs";
+import { SqlAnnotations, SqlSchemaIR, SqlSchemaIRNode, SqlSchemaTarget, SqlTableIR, SqlTableIRInput } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/postgres-schema-ir.d.ts
+interface PostgresSchemaIRInput {
+  readonly tables: Record<string, SqlTableIR | SqlTableIRInput>;
+  readonly pgSchemaName: string;
+  readonly pgVersion: string;
+  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+  readonly roles: readonly PostgresRole[];
+  readonly existingSchemas: readonly string[];
+  readonly nativeEnumTypeNames: readonly string[];
+}
+/**
+ * Postgres-specific schema IR. Mirrors the structure of `SqlSchemaIR`
+ * (same `tables` + optional `annotations` fields) and adds typed fields for
+ * data the postgres adapter collects during introspection.
+ *
+ * Extends `SqlSchemaIRNode` directly rather than `SqlSchemaIR` because
+ * `SqlSchemaIR` calls `freezeNode` in its constructor, which prevents
+ * subclass field initialisation. `PostgresSchemaIR` replicates the minimal
+ * `SqlSchemaIR` structure and freezes itself at the end of its own
+ * constructor.
+ *
+ * RLS-specific fields (`rlsPolicies`, `roles`) are typed top-level fields on
+ * this class — no `Reflect.get`, no untyped annotation bag access. The
+ * `annotations.pg` bag is populated with only the subset the family layer
+ * reads (`nativeEnumTypeNames`, `existingSchemas`, `schema`) so family-layer
+ * PSL inference and namespace verification continue to work without knowing
+ * about RLS.
+ *
+ * Nothing RLS-specific leaks into the sql-family layer.
+ */
+declare class PostgresSchemaIR extends SqlSchemaIRNode {
+  readonly nodeTarget: SqlSchemaTarget;
+  readonly tables: Readonly<Record<string, SqlTableIR>>;
+  readonly annotations?: SqlAnnotations;
+  readonly pgSchemaName: string;
+  readonly pgVersion: string;
+  readonly rlsPolicies: readonly PostgresRlsPolicy[];
+  readonly roles: readonly PostgresRole[];
+  readonly existingSchemas: readonly string[];
+  readonly nativeEnumTypeNames: readonly string[];
+  constructor(input: PostgresSchemaIRInput);
+}
+/**
+ * Structural guard for `PostgresSchemaIR`, narrowing on the `nodeTarget`
+ * discriminant rather than `instanceof`. `nodeTarget` is an enumerable own field
+ * (a plain class-field initializer), so it survives the `{ ...schema, tables }`
+ * spread the multi-space verify path (`projectSchemaToSpace`) produces — that
+ * projected object is not a class instance but retains every enumerable own
+ * property. The family-level `kind = 'sql-schema-ir'` discriminator is unusable
+ * here: it is shared by every SQL schema-IR node and is non-enumerable (dropped
+ * by the spread).
+ */
+declare function isPostgresSchemaIR(schema: SqlSchemaIR): schema is PostgresSchemaIR;
+//#endregion
+export { PostgresSchemaIRInput as n, isPostgresSchemaIR as r, PostgresSchemaIR as t };
+//# sourceMappingURL=postgres-schema-ir-BQ3RpZMz.d.mts.map

package/dist/postgres-schema-ir-BQ3RpZMz.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-BQ3RpZMz.d.mts","names":[],"sources":["../src/core/postgres-schema-ir.ts"],"mappings":";;;;;UAYiB,qBAAA;EAAA,SACN,MAAA,EAAQ,MAAA,SAAe,UAAA,GAAa,eAAA;EAAA,SACpC,YAAA;EAAA,SACA,SAAA;EAAA,SACA,WAAA,WAAsB,iBAAA;EAAA,SACtB,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;AAAA;;;;;;;;;;;;;;;;;AAAmB;AAuB9B;;;cAAa,gBAAA,SAAyB,eAAA;EAAA,SAC3B,UAAA,EAAY,eAAA;EAAA,SACZ,MAAA,EAAQ,QAAA,CAAS,MAAA,SAAe,UAAA;EAAA,SACxB,WAAA,GAAc,cAAA;EAAA,SACtB,YAAA;EAAA,SACA,SAAA;EAAA,SACA,WAAA,WAAsB,iBAAA;EAAA,SACtB,KAAA,WAAgB,YAAA;EAAA,SAChB,eAAA;EAAA,SACA,mBAAA;cAEG,KAAA,EAAO,qBAAA;AAAA;;;;;;;;;;;iBA6CL,kBAAA,CAAmB,MAAA,EAAQ,WAAA,GAAc,MAAA,IAAU,gBAAgB"}

package/dist/postgres-schema-ir-annotations-El62Sywa.mjs

@@ -0,0 +1,14 @@
+import { r as isPostgresSchema } from "./postgres-schema-BVDr_61a.mjs";
+import { n as isPostgresSchemaIR } from "./postgres-schema-ir-BF0X8jit.mjs";
+import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
+//#region src/core/postgres-schema-ir-annotations.ts
+function resolveDdlSchemaForNamespaceStorage(storage, namespaceId, schemaIr) {
+	if (namespaceId === UNBOUND_NAMESPACE_ID) return (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : void 0) ?? "public";
+	const namespace = storage.namespaces[namespaceId];
+	if (namespace && isPostgresSchema(namespace)) return namespace.ddlSchemaName(storage);
+	return namespaceId;
+}
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage as t };
+
+//# sourceMappingURL=postgres-schema-ir-annotations-El62Sywa.mjs.map

package/dist/postgres-schema-ir-annotations-El62Sywa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-schema-ir-annotations-El62Sywa.mjs","names":[],"sources":["../src/core/postgres-schema-ir-annotations.ts"],"sourcesContent":["import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { SqlSchemaIR } from '@prisma-next/sql-schema-ir/types';\nimport { isPostgresSchema } from './postgres-schema';\nimport { isPostgresSchemaIR } from './postgres-schema-ir';\n\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n  schemaIr?: SqlSchemaIR,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return (\n      (schemaIr && isPostgresSchemaIR(schemaIr) ? schemaIr.pgSchemaName : undefined) ?? 'public'\n    );\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;AAMA,SAAgB,oCACd,SACA,aACA,UACQ;CACR,IAAI,gBAAgB,sBAClB,QACG,YAAY,mBAAmB,QAAQ,IAAI,SAAS,eAAe,KAAA,MAAc;CAGtF,MAAM,YAAY,QAAQ,WAAW;CACrC,IAAI,aAAa,iBAAiB,SAAS,GACzC,OAAO,UAAU,cAAc,OAAO;CAExC,OAAO;AACT"}

package/dist/render-ops.d.mts

@@ -1,4 +1,4 @@
-import { t as PostgresPlanTargetDetails } from "./planner-target-details-CIY6tLeo.mjs";
+import { t as PostgresPlanTargetDetails } from "./planner-target-details-HkP4RrRO.mjs";
 import { SqlMigrationPlanOperation } from "@prisma-next/family-sql/control";
 import { OpFactoryCall } from "@prisma-next/framework-components/control";
 import { ExecuteRequestLowerer } from "@prisma-next/family-sql/control-adapter";

package/dist/rls-canonicalize.d.mts

@@ -0,0 +1,2 @@
+import { i as normalizePredicate, n as RlsPolicyOperation, r as computeContentHash, t as ContentHashParts } from "./canonicalize-CAbXtVtB.mjs";
+export { type ContentHashParts, type RlsPolicyOperation, computeContentHash, normalizePredicate };

package/dist/rls-canonicalize.mjs

@@ -0,0 +1,2 @@
+import { n as normalizePredicate, t as computeContentHash } from "./canonicalize-Bn3BM1Cn.mjs";
+export { computeContentHash, normalizePredicate };

package/dist/runtime.d.mts

@@ -1,5 +1,5 @@
 import { AnyCodecDescriptor } from "@prisma-next/framework-components/codec";
-import { Namespace } from "@prisma-next/framework-components/ir";
+import { AnyEntityKindDescriptor, Namespace } from "@prisma-next/framework-components/ir";
 import { SqlNamespaceTablesInput, SqlStorage } from "@prisma-next/sql-contract/types";
 import { SqlContractSerializerBase } from "@prisma-next/family-sql/ir";
 import { Contract } from "@prisma-next/contract/types";
@@ -8,11 +8,12 @@ import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/postgres-contract-serializer.d.ts
 declare class PostgresContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
-  constructor();
+  constructor(extraPackEntityKinds?: readonly AnyEntityKindDescriptor[]);
   protected get defaultNamespaceId(): string;
   protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
   serializeContract(contract: Contract<SqlStorage>): JsonObject;
   private serializePostgresNamespace;
+  private serializeJsonObject;
   private serializeJsonValue;
 }
 //#endregion

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cAkEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;;gBAM1D,kBAAA;EAAA,UAIJ,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA0BN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QAuCpD,0BAAA;EAAA,QAyBA,kBAAA;AAAA;;;UChKO,6BAAA,SAAsC,qBAAqB;;;;;ADyD5E;;cCjDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/core/postgres-contract-serializer.ts","../src/exports/runtime.ts"],"mappings":";;;;;;;;;cAqEa,0BAAA,SAAmC,yBAAA,CAA0B,QAAA,CAAS,UAAA;cACrE,oBAAA,YAA+B,uBAAA;EAAA,cAKpB,kBAAA;EAAA,UAIJ,wBAAA,CACjB,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EA4BN,iBAAA,CAAkB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,UAAA;EAAA,QA0CpD,0BAAA;EAAA,QAgCA,mBAAA;EAAA,QAOA,kBAAA;AAAA;;;UCtLO,6BAAA,SAAsC,qBAAqB;;;;;AD4D5E;;cCpDM,+BAAA,EAAiC,uBAAA,oBAGrC,6BAAA;EAAA,SAES,MAAA,iBAAuB,kBAAA;AAAA"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
-import { n as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-CpGygXpI.mjs";
-import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k3TAcPMY.mjs";
+import { n as postgresTargetDescriptorMetaRuntime } from "./descriptor-meta-b_SzXwen.mjs";
+import { t as PostgresContractSerializer } from "./postgres-contract-serializer-k5eg5ZUZ.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

@@ -0,0 +1,8 @@
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/postgres-schema-ir-annotations.d.ts
+declare function resolveDdlSchemaForNamespaceStorage(storage: SqlStorage, namespaceId: string, schemaIr?: SqlSchemaIR): string;
+//#endregion
+export { resolveDdlSchemaForNamespaceStorage };
+//# sourceMappingURL=schema-ir-annotations.d.mts.map

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

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

package/dist/schema-ir-annotations.mjs

@@ -0,0 +1,2 @@
+import { t as resolveDdlSchemaForNamespaceStorage } from "./postgres-schema-ir-annotations-El62Sywa.mjs";
+export { resolveDdlSchemaForNamespaceStorage };

package/dist/types.d.mts

@@ -1,141 +1,6 @@
-import { t as PostgresTableSource } from "./table-source-BvFo7gVs.mjs";
+import { n as PostgresRlsPolicyInput, r as RlsPolicyOperation, t as PostgresRlsPolicy } from "./postgres-rls-policy-D_z1osEq.mjs";
 import { t as PostgresColumnDefault } from "./types-BDKkx8MA.mjs";
-import { NamespaceBase } from "@prisma-next/framework-components/ir";
-import { CfExpr } from "@prisma-next/sql-relational-core/contract-free";
-import { SqlNamespaceEntries, SqlNamespaceTablesInput, SqlStorage, StorageTable, StorageValueSet } from "@prisma-next/sql-contract/types";
-
-//#region src/core/postgres-schema.d.ts
-interface PostgresSchemaInput {
-  readonly id: string;
-  readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
-}
-/**
- * Postgres target `Namespace` concretion — a Postgres schema (`CREATE
- * SCHEMA …`). Each Postgres `SqlStorage` carries a
- * `namespaces: Record<NamespaceId, PostgresSchema>` map populated by
- * the Postgres PSL interpreter from `namespace { … }` AST buckets.
- *
- * `entries` holds entity-kind maps (`table`, `valueSet`). Qualifier
- * emission is the rendering seam: DDL / SQL emission asks the namespace
- * for its qualifier (`"<schema>"`) or for a qualified table name
- * (`"<schema>"."<table>"`) and consumes the result polymorphically.
- * The unbound singleton below overrides these methods to elide the
- * prefix entirely — call sites stay polymorphic and never branch on
- * `id === UNBOUND_NAMESPACE_ID`.
- */
-declare class PostgresSchema extends NamespaceBase {
-  /**
-   * Stable singleton reference for the late-bound slot. Materialised
-   * lazily below the singleton subclass declaration so the static
-   * initialiser sees the subclass before assigning. Consumers always
-   * reach for `PostgresSchema.unbound` (or `PostgresUnboundSchema.instance`
-   * — same identity).
-   */
-  static unbound: PostgresUnboundSchema;
-  readonly kind: 'schema';
-  readonly id: string;
-  readonly entries: SqlNamespaceEntries;
-  constructor(input: PostgresSchemaInput);
-  get table(): Readonly<Record<string, StorageTable>>;
-  get valueSet(): Readonly<Record<string, StorageValueSet>> | undefined;
-  /**
-   * The bare schema qualifier as it would appear in a rendered SQL
-   * fragment (already quoted). The unbound-schema singleton overrides
-   * this to return `''`.
-   */
-  qualifier(): string;
-  /**
-   * Qualify a table name with the schema prefix
-   * (`"<schema>"."<table>"`). The unbound-schema singleton overrides
-   * this to emit just `"<table>"` so the resolved DDL is unqualified
-   * and `search_path` decides where the object lands at runtime.
-   */
-  qualifyTable(tableName: string): string;
-  /**
-   * Render a SQL string-literal containing the qualified-name form
-   * suitable for `to_regclass(...)` arguments (e.g. `'"public"."user"'`).
-   * The unbound singleton overrides this to elide the schema prefix
-   * (`'"user"'`) so `search_path` resolves the object at runtime.
-   */
-  regclassLiteral(name: string): string;
-  /**
-   * Render a SQL expression that evaluates to this namespace's schema
-   * name at runtime, ready to drop into a `WHERE table_schema = …` /
-   * `WHERE n.nspname = …` clause. Named schemas emit a quoted SQL
-   * literal (`'public'`); the unbound singleton overrides this to emit
-   * `current_schema()` so catalog queries match whichever schema the
-   * connection's `search_path` resolved at runtime.
-   */
-  schemaSqlExpression(): string;
-  /**
-   * Typed-AST counterpart of {@link schemaSqlExpression}: the expression a
-   * builder-built catalog check compares `n.nspname` / `table_schema`
-   * against. Named schemas bind the schema name as a text parameter; the
-   * unbound singleton overrides this to the opaque `current_schema()`
-   * expression so the live connection's `search_path` decides at runtime.
-   */
-  schemaFilterExpression(): CfExpr;
-  /**
-   * Typed-AST counterpart of {@link qualifyTable}: the FROM source a
-   * builder-built check uses to address a user table in this namespace.
-   * Named schemas qualify (`"schema"."table"`); the unbound singleton
-   * overrides this to leave the table unqualified so `search_path`
-   * resolves it at runtime.
-   */
-  tableSource(tableName: string, alias?: string): PostgresTableSource;
-  /**
-   * The bare schema name a DDL planner should target when emitting
-   * statements that need to identify this namespace in the live
-   * database (e.g. `CREATE TABLE "<ddlSchemaName>"."<table>" …`,
-   * catalog filters, planner conflict lookups). Named schemas resolve
-   * to their own id. The `PostgresUnboundSchema` singleton inherits
-   * this and returns `UNBOUND_NAMESPACE_ID` — callers that dispatch
-   * through `qualifyTableName` route through the polymorphic
-   * `PostgresUnboundSchema` overrides and produce unqualified
-   * (search-path-resolved) output automatically.
-   */
-  ddlSchemaName(_storage: SqlStorage): string;
-}
-/**
- * Singleton subclass for the reserved sentinel namespace id
- * (`UNBOUND_NAMESPACE_ID`) — the late-bound Postgres slot whose binding
- * the connection's `search_path` resolves at runtime. Overrides
- * qualifier emission to elide the schema prefix; call sites that consume
- * `qualifier()` / `qualifyTable()` get unqualified output without
- * branching on the namespace id.
- *
- * This is the target-side materialization of "the framework provides
- * affordances; targets implement specifics": the framework names the
- * sentinel; Postgres decides what late-bound means here (the table
- * name, naked — the schema is supplied by the live connection's
- * `search_path`).
- *
- * `ddlSchemaName` is inherited from `PostgresSchema` and returns
- * `UNBOUND_NAMESPACE_ID`. Downstream helpers such as `qualifyTableName`
- * route through the polymorphic factory and produce unqualified output
- * automatically.
- */
-declare class PostgresUnboundSchema extends PostgresSchema {
-  static readonly instance: PostgresUnboundSchema;
-  constructor(input?: PostgresSchemaInput);
-  qualifier(): string;
-  qualifyTable(tableName: string): string;
-  schemaSqlExpression(): string;
-  schemaFilterExpression(): CfExpr;
-  tableSource(tableName: string, alias?: string): PostgresTableSource;
-}
-/**
- * Target-supplied `Namespace` factory the Postgres target plumbs
- * through `defineContract({ createNamespace })` and the SQL PSL
- * interpreter. Returns the unbound singleton for the framework
- * sentinel and a fresh `PostgresSchema` for any other coordinate.
- *
- * The factory has no per-call state — every named id deterministically
- * maps to a distinct schema instance — so callers can pass it through
- * by reference and trust the resulting `SqlStorage.namespaces` map to
- * be value-stable for a given input set.
- */
-declare function postgresCreateNamespace(input: SqlNamespaceTablesInput): PostgresSchema;
-//#endregion
-export { type PostgresColumnDefault, PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
-//# sourceMappingURL=types.d.mts.map
+import { n as PostgresRoleInput, t as PostgresRole } from "./postgres-role-_CCuyPCQ.mjs";
+import { i as postgresCreateNamespace, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-D0h4lsw2.mjs";
+import { n as PostgresSchemaIRInput, r as isPostgresSchemaIR, t as PostgresSchemaIR } from "./postgres-schema-ir-BQ3RpZMz.mjs";
+export { type PostgresColumnDefault, PostgresRlsPolicy, type PostgresRlsPolicyInput, PostgresRole, type PostgresRoleInput, PostgresSchema, PostgresSchemaIR, type PostgresSchemaIRInput, PostgresUnboundSchema, type RlsPolicyOperation, isPostgresSchema, isPostgresSchemaIR, postgresCreateNamespace };

package/dist/types.mjs

@@ -1,2 +1,3 @@
-import { i as postgresCreateNamespace, n as PostgresUnboundSchema, t as PostgresSchema } from "./postgres-schema-COGZ1ark.mjs";
-export { PostgresSchema, PostgresUnboundSchema, postgresCreateNamespace };
+import { d as PostgresRlsPolicy, i as postgresCreateNamespace, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema, u as PostgresRole } from "./postgres-schema-BVDr_61a.mjs";
+import { n as isPostgresSchemaIR, t as PostgresSchemaIR } from "./postgres-schema-ir-BF0X8jit.mjs";
+export { PostgresRlsPolicy, PostgresRole, PostgresSchema, PostgresSchemaIR, PostgresUnboundSchema, isPostgresSchema, isPostgresSchemaIR, postgresCreateNamespace };

package/package.json

@@ -1,32 +1,34 @@
 {
   "name": "@prisma-next/target-postgres",
-  "version": "0.14.0-dev.10",
+  "version": "0.14.0-dev.12",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.14.0-dev.10",
-    "@prisma-next/contract": "0.14.0-dev.10",
-    "@prisma-next/errors": "0.14.0-dev.10",
-    "@prisma-next/family-sql": "0.14.0-dev.10",
-    "@prisma-next/framework-components": "0.14.0-dev.10",
-    "@prisma-next/migration-tools": "0.14.0-dev.10",
-    "@prisma-next/ts-render": "0.14.0-dev.10",
-    "@prisma-next/sql-contract": "0.14.0-dev.10",
-    "@prisma-next/sql-errors": "0.14.0-dev.10",
-    "@prisma-next/sql-operations": "0.14.0-dev.10",
-    "@prisma-next/sql-relational-core": "0.14.0-dev.10",
-    "@prisma-next/sql-schema-ir": "0.14.0-dev.10",
-    "@prisma-next/utils": "0.14.0-dev.10",
+    "@prisma-next/cli": "0.14.0-dev.12",
+    "@prisma-next/contract": "0.14.0-dev.12",
+    "@prisma-next/errors": "0.14.0-dev.12",
+    "@prisma-next/family-sql": "0.14.0-dev.12",
+    "@prisma-next/framework-components": "0.14.0-dev.12",
+    "@prisma-next/migration-tools": "0.14.0-dev.12",
+    "@prisma-next/ts-render": "0.14.0-dev.12",
+    "@prisma-next/sql-contract": "0.14.0-dev.12",
+    "@prisma-next/sql-errors": "0.14.0-dev.12",
+    "@prisma-next/sql-operations": "0.14.0-dev.12",
+    "@prisma-next/sql-relational-core": "0.14.0-dev.12",
+    "@prisma-next/sql-schema-ir": "0.14.0-dev.12",
+    "@prisma-next/utils": "0.14.0-dev.12",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.0",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/test-utils": "0.14.0-dev.10",
-    "@prisma-next/tsconfig": "0.14.0-dev.10",
-    "@prisma-next/tsdown": "0.14.0-dev.10",
+    "@prisma-next/psl-parser": "0.14.0-dev.12",
+    "@prisma-next/sql-contract-psl": "0.14.0-dev.12",
+    "@prisma-next/test-utils": "0.14.0-dev.12",
+    "@prisma-next/tsconfig": "0.14.0-dev.12",
+    "@prisma-next/tsdown": "0.14.0-dev.12",
     "tsdown": "0.22.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8"
@@ -68,7 +70,9 @@
     "./planner-target-details": "./dist/planner-target-details.mjs",
     "./render-ops": "./dist/render-ops.mjs",
     "./render-typescript": "./dist/render-typescript.mjs",
+    "./rls-canonicalize": "./dist/rls-canonicalize.mjs",
     "./runtime": "./dist/runtime.mjs",
+    "./schema-ir-annotations": "./dist/schema-ir-annotations.mjs",
     "./sql-utils": "./dist/sql-utils.mjs",
     "./types": "./dist/types.mjs",
     "./package.json": "./package.json"