@prisma-next/target-postgres 0.14.0-dev.22 → 0.14.0-dev.24

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

@@ -1 +0,0 @@
-{"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

@@ -1,60 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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-CWHQ-H9Y.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"postgres-schema-ir-annotations-CWHQ-H9Y.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/src/core/migrations/verify-postgres-rls-policies.ts

@@ -1,62 +0,0 @@
-import type { Contract } from '@prisma-next/contract/types';
-import type { SchemaDiffIssue } from '@prisma-next/framework-components/control';
-import { diffNodes } from '@prisma-next/framework-components/control';
-import { UNBOUND_NAMESPACE_ID } from '@prisma-next/framework-components/ir';
-import type { SqlStorage } from '@prisma-next/sql-contract/types';
-import { isPostgresSchema } from '../postgres-schema';
-import type { PostgresSchemaIR } from '../postgres-schema-ir';
-
-// Postgres binds the late-bound (`__unbound__`) namespace to the `public`
-// schema, so an unbound contract owns `public` in the live database. Both the
-// contract slot ids and the introspected policy coordinates can carry either
-// form depending on how the schema was lowered, so normalize both sides to the
-// same id before comparing ownership.
-const POSTGRES_DEFAULT_NAMESPACE_ID = 'public';
-
-function resolveNamespaceId(namespaceId: string): string {
-  return namespaceId === UNBOUND_NAMESPACE_ID ? POSTGRES_DEFAULT_NAMESPACE_ID : namespaceId;
-}
-
-/**
- * Computes RLS policy drift between the contract and the live DB schema using
- * the generic {@link diffNodes} differ. Returns `SchemaDiffIssue[]` keyed by
- * the full `EntityCoordinate` (plane + namespaceId + entityKind + entityName).
- *
- * Both sides supply `PostgresRlsPolicy` nodes that implement `DiffableNode`
- * with a concrete namespace coordinate — the contract carries explicit
- * `namespaceId` set during lowering (e.g. `'public'`); the introspected schema
- * carries the resolved DDL schema name. The differ matches purely on coordinate
- * identity; no namespace interpretation happens here.
- *
- * The diff is scoped to the namespaces the verified contract owns. The live
- * schema introspection returns every policy across all DB schemas, but a policy
- * in a namespace this contract does not own belongs to another contract space
- * (or is external) and must not be reported as extra. Without this scope a space
- * that owns only `auth`/`storage` (e.g. the supabase extension space) would flag
- * the application space's `public.*` policies as extra during verify.
- *
- * Ownership is the set of namespaces the contract declares (its
- * `storage.namespaces` slot keys), with the late-bound `__unbound__` slot
- * resolved to the Postgres default `public` so a single-namespace contract still
- * owns — and diffs — its `public` policies.
- */
-export function diffPostgresRlsPolicies(input: {
-  readonly contract: Contract<SqlStorage>;
-  readonly schema: PostgresSchemaIR;
-}): readonly SchemaDiffIssue[] {
-  const { contract, schema } = input;
-
-  const ownedNamespaceIds = new Set(
-    Object.keys(contract.storage.namespaces).map(resolveNamespaceId),
-  );
-
-  const expected = Object.values(contract.storage.namespaces).flatMap((ns) =>
-    isPostgresSchema(ns) ? Object.values(ns.policy) : [],
-  );
-
-  const actual = schema.rlsPolicies.filter((policy) =>
-    ownedNamespaceIds.has(resolveNamespaceId(policy.namespaceId)),
-  );
-
-  return diffNodes(expected, actual);
-}