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

package/dist/pack.d.mts

@@ -1,10 +1,56 @@
-import { r as CodecTypes } from "./codec-types-DHCkwPKE.mjs";
+import { Z as postgresQualifyColumnType } from "./codecs-D7W9O0Xx.mjs";
+import { r as CodecTypes } from "./codec-types-CTfT4U4O.mjs";
+import { t as PostgresRlsPolicy } from "./postgres-rls-policy--CSddvMR.mjs";
+import { a as postgresCreateNamespace, c as PostgresRlsEnablement, l as PostgresRlsEnablementInput, o as PostgresRole, u as PostgresNativeEnum } from "./postgres-schema-DKq6s1P3.mjs";
+import { PslExtensionBlock } from "@prisma-next/framework-components/authoring";
+import { EntityHandleLoweringInput, LoweredPackEntity, ResolvedPslModelRefs } from "@prisma-next/sql-contract/entity-handle-lowering-hook";
 
+//#region src/core/authoring.d.ts
+interface RlsPolicyExtensionBlock extends PslExtensionBlock {
+  readonly namespaceId: string;
+  /**
+   * Model refs the family interpreter resolved from the block's descriptor-
+   * declared `refKind: 'model'` parameters before invoking this factory
+   * (keyed by parameter name). An unresolved required ref is the
+   * interpreter's diagnostic; the factory is never called with one missing.
+   */
+  readonly resolvedModelRefs?: ResolvedPslModelRefs;
+}
+/** A parsed `role` block annotated with its lexical namespace id by the interpreter. */
+interface RoleExtensionBlock extends PslExtensionBlock {
+  readonly namespaceId: string;
+}
+/**
+ * The SQL-family entity-handle batch lowering hook for the Postgres pack
+ * (`SqlEntityHandleLoweringContribution`). Receives every `entities` handle
+ * whose kind this pack registered — batch, so the cross-entity diagnostics
+ * (duplicate prefix, policy without rlsEnabled, duplicate role) can see
+ * sibling handles — and lowers them with the same keying and hash assembly
+ * as the PSL path: `policy` keyed by prefix (wire name via
+ * {@link buildRlsPolicyEntity}), `rls` keyed by table name, `role` keyed by
+ * name and filed under the default namespace (roles are declared
+ * contract-wide; PSL has no role block to set a precedent).
+ */
+declare function postgresLowerEntityHandles(input: EntityHandleLoweringInput): readonly LoweredPackEntity[];
+//#endregion
 //#region src/core/descriptor-meta.d.ts
 declare const postgresTargetDescriptorMetaBase: {
   readonly defaultNamespaceId: "public";
   readonly authoring: {
-    readonly type: {};
+    readonly type: {
+      readonly pg: {
+        readonly enum: {
+          readonly kind: "typeConstructor";
+          readonly entityRefArg: {
+            readonly index: 0;
+            readonly entityKind: "native_enum";
+          };
+          readonly output: {
+            readonly codecId: "pg/enum@1";
+          };
+        };
+      };
+    };
     readonly field: {
       readonly text: {
         readonly kind: "fieldPreset";
@@ -137,7 +183,279 @@ declare const postgresTargetDescriptorMetaBase: {
         };
       };
     };
-    readonly entityTypes: {};
+    readonly entityTypes: {
+      readonly role: {
+        readonly kind: "entity";
+        readonly discriminator: "role";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "role";
+          name: string;
+          namespaceId: string;
+          control?: "external";
+        }, {}>;
+        readonly output: {
+          readonly factory: (block: RoleExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresRole | undefined;
+        };
+      };
+      readonly rls: {
+        readonly kind: "entity";
+        readonly discriminator: "rls";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "rls";
+          tableName: string;
+          namespaceId: string;
+        }, {}>;
+        readonly output: {
+          readonly factory: (input: PostgresRlsEnablementInput) => PostgresRlsEnablement;
+        };
+      };
+      readonly policy: {
+        readonly kind: "entity";
+        readonly discriminator: "policy";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "policy";
+          name: string;
+          prefix: string;
+          tableName: string;
+          namespaceId: string;
+          operation: "delete" | "select" | "insert" | "update" | "all";
+          roles: readonly string[];
+          permissive: boolean;
+          using?: string;
+          withCheck?: string;
+        }, {}>;
+        readonly output: {
+          readonly factory: (block: RlsPolicyExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresRlsPolicy | undefined;
+        };
+      };
+      readonly native_enum: {
+        readonly kind: "entity";
+        readonly discriminator: "native_enum";
+        readonly validatorSchema: import("arktype/internal/variants/object.ts").ObjectType<{
+          kind: "postgres-enum";
+          typeName: string;
+          members: readonly string[];
+          control?: "external" | "managed" | "tolerated" | "observed";
+        }, {}>;
+        readonly output: {
+          factory: (block: import("@prisma-next/psl-parser").PslExtensionBlock, ctx: import("@prisma-next/framework-components/authoring").AuthoringEntityContext) => PostgresNativeEnum | undefined;
+          deriveValueSet: (entity: PostgresNativeEnum) => {
+            kind: "valueSet";
+            values: string[];
+          };
+        };
+      };
+    };
+    readonly pslBlockDescriptors: {
+      readonly policy_select: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_select";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_delete: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_delete";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_insert: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_insert";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_update: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_update";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly policy_all: {
+        readonly kind: "pslBlock";
+        readonly keyword: "policy_all";
+        readonly discriminator: "policy";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {
+          readonly target: {
+            readonly kind: "ref";
+            readonly refKind: "model";
+            readonly scope: "same-namespace";
+            readonly required: true;
+          };
+          readonly roles: {
+            readonly kind: "list";
+            readonly of: {
+              readonly kind: "ref";
+              readonly refKind: "role";
+              readonly scope: "cross-space";
+            };
+          };
+          readonly using: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+          readonly withCheck: {
+            readonly kind: "value";
+            readonly codecId: "pg/text@1";
+            readonly required: true;
+          };
+        };
+        readonly requiresModelAttribute: {
+          readonly parameter: "target";
+          readonly attribute: "rls";
+        };
+      };
+      readonly native_enum: {
+        readonly kind: "pslBlock";
+        readonly keyword: "native_enum";
+        readonly discriminator: "native_enum";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {};
+        readonly variadicParameters: true;
+      };
+      readonly role: {
+        readonly kind: "pslBlock";
+        readonly keyword: "role";
+        readonly discriminator: "role";
+        readonly name: {
+          readonly required: true;
+        };
+        readonly parameters: {};
+      };
+    };
+    readonly modelAttributes: {
+      readonly rls: {
+        readonly kind: "modelAttribute";
+        readonly attribute: "rls";
+        readonly spec: import("@prisma-next/psl-parser").AttributeSpec<{}>;
+        readonly lower: (_parsed: Record<never, never>, ctx: import("@prisma-next/framework-components/authoring").AuthoringModelAttributeContext) => {
+          key: string;
+          entity: PostgresRlsEnablement;
+        };
+      };
+    };
+    readonly createNamespace: typeof postgresCreateNamespace;
+    readonly qualifyColumnType: typeof postgresQualifyColumnType;
+    readonly lowerEntityHandles: typeof postgresLowerEntityHandles;
   };
   readonly kind: "target";
   readonly familyId: "sql";

package/dist/pack.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/descriptor-meta.ts"],"mappings":";;;cAQM,gCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAQI,UAAA;AAAA;AAAA,cAEG,4BAAA,SAAqC,gCAAA;EAAA,SACvC,YAAA,GAAe,UAAU;AAAA"}
+{"version":3,"file":"pack.d.mts","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta.ts"],"mappings":";;;;;;;;UA8DiB,uBAAA,SAAgC,iBAAiB;EAAA,SACvD,WAAA;EA+pBkB;AAAA;;;;ACltB+B;EDktB/B,SAxpBlB,iBAAA,GAAoB,oBAAA;AAAA;;UAId,kBAAA,SAA2B,iBAAiB;EAAA,SAClD,WAAW;AAAA;;;;;;;;;;;;iBAipBN,0BAAA,CACd,KAAA,EAAO,yBAAA,YACG,iBAAiB;;;cChtBvB,gCAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAaI,kBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEG,4BAAA,SAAqC,gCAAA;EAAA,SACvC,YAAA,GAAe,UAAU;AAAA"}

package/dist/pack.mjs

@@ -1,2 +1,2 @@
-import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CpGygXpI.mjs";
+import { t as postgresTargetDescriptorMeta } from "./descriptor-meta-CFQKLXl_.mjs";
 export { postgresTargetDescriptorMeta as default };