@prisma-next/target-postgres 0.16.0-dev.3 → 0.16.0-dev.31

package/dist/{resolve-ddl-schema-D0wi_P9Q.mjs.map → resolve-ddl-schema-BAsJEKW8.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"resolve-ddl-schema-D0wi_P9Q.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 { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\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\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,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"}
+{"version":3,"file":"resolve-ddl-schema-BAsJEKW8.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 { DEFAULT_NAMESPACE_ID } from '../namespace-ids';\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\n * `DEFAULT_NAMESPACE_ID` (the search-path default for offline planning); a\n * bare object payload (used by some tests) falls back to the namespace id\n * itself.\n */\nexport function resolveDdlSchemaForNamespaceStorage(\n  storage: SqlStorage,\n  namespaceId: string,\n): string {\n  if (namespaceId === UNBOUND_NAMESPACE_ID) {\n    return DEFAULT_NAMESPACE_ID;\n  }\n  const namespace = storage.namespaces[namespaceId];\n  if (namespace && isPostgresSchema(namespace)) {\n    return namespace.ddlSchemaName(storage);\n  }\n  return namespaceId;\n}\n"],"mappings":";;;;;;;;;;;;AAaA,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/rls-canonicalize.d.mts

@@ -1,26 +1,2 @@
-import { a as normalizePredicate, i as computeContentHash, n as POLICY_OPERATION_PREDICATES, r as RlsPolicyOperation, t as ContentHashParts } from "./canonicalize-D1F4vUnP.mjs";
-//#region src/core/rls/wire-name.d.ts
-interface RlsPolicyWireName {
-  /** The user-supplied part before the `_<8hex>` suffix. */
-  readonly prefix: string;
-  /** The 8-lowercase-hex content-hash suffix. */
-  readonly hash: string;
-}
-/**
- * Assembles an RLS policy wire name from its user-supplied prefix and its
- * 8-hex content-hash suffix. This module owns the `<prefix>_<hash>` format
- * on both sides — construction here and parsing in
- * {@link parseRlsPolicyWireName} — so the two never drift.
- */
-declare function formatRlsPolicyWireName(prefix: string, hash: string): string;
-/**
- * Splits an RLS policy wire name (`<prefix>_<8hex>`) into its prefix and
- * content-hash suffix. Returns `undefined` when the name does not follow the
- * wire-name shape (e.g. a policy created outside the toolchain) — callers
- * treat such names as all-prefix. Consumed by introspection (prefix
- * extraction) and by rename pairing (same hash, different prefix).
- */
-declare function parseRlsPolicyWireName(name: string): RlsPolicyWireName | undefined;
-//#endregion
-export { type ContentHashParts, POLICY_OPERATION_PREDICATES, type RlsPolicyOperation, type RlsPolicyWireName, computeContentHash, formatRlsPolicyWireName, normalizePredicate, parseRlsPolicyWireName };
-//# sourceMappingURL=rls-canonicalize.d.mts.map
+import { i as computeContentHash, n as POLICY_OPERATION_PREDICATES, r as RlsPolicyOperation, t as ContentHashParts } from "./canonicalize-CQlxSR4D.mjs";
+export { type ContentHashParts, POLICY_OPERATION_PREDICATES, type RlsPolicyOperation, computeContentHash };

package/dist/rls-canonicalize.mjs

@@ -1,2 +1,2 @@
-import { a as normalizePredicate, i as computeContentHash, n as parseRlsPolicyWireName, r as POLICY_OPERATION_PREDICATES, t as formatRlsPolicyWireName } from "./wire-name-DbQ9-2RC.mjs";
-export { POLICY_OPERATION_PREDICATES, computeContentHash, formatRlsPolicyWireName, normalizePredicate, parseRlsPolicyWireName };
+import { n as computeContentHash, t as POLICY_OPERATION_PREDICATES } from "./canonicalize-C7zKHw8m.mjs";
+export { POLICY_OPERATION_PREDICATES, computeContentHash };

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-DebHMqGR.mjs";
+import { n as PostgresContractSerializer, t as PostgresContractView } from "./postgres-contract-view-BeIEyZfD.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.mjs

@@ -1,2 +1,2 @@
-import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-D0wi_P9Q.mjs";
+import { t as resolveDdlSchemaForNamespaceStorage } from "./resolve-ddl-schema-BAsJEKW8.mjs";
 export { resolveDdlSchemaForNamespaceStorage };

package/dist/{sql-utils-SU4FDvIV.mjs → sql-utils-B2lzkKfP.mjs}

@@ -1,3 +1,4 @@
+import { n as postgresError } from "./errors-DBSNx7EJ.mjs";
 //#region src/core/sql-utils.ts
 /**
 * Shared SQL utility functions for the Postgres target.
@@ -10,16 +11,6 @@
 * escaping/validation behavior, and the target package is the natural shared
 * home that both adapters can depend on without crossing planes.
 */
-var SqlEscapeError = class extends Error {
-	value;
-	kind;
-	constructor(message, value, kind) {
-		super(message);
-		this.value = value;
-		this.kind = kind;
-		this.name = "SqlEscapeError";
-	}
-};
 const MAX_IDENTIFIER_LENGTH = 63;
 /**
 * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
@@ -29,11 +20,17 @@ const MAX_IDENTIFIER_LENGTH = 63;
 * - Rejects empty identifiers
 * - Warns on identifiers exceeding PostgreSQL's 63-character limit
 *
-* @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the identifier contains null bytes or is empty
 */
 function quoteIdentifier(identifier) {
-	if (identifier.length === 0) throw new SqlEscapeError("Identifier cannot be empty", identifier, "identifier");
-	if (identifier.includes("\0")) throw new SqlEscapeError("Identifier cannot contain null bytes", identifier.replace(/\0/g, "\\0"), "identifier");
+	if (identifier.length === 0) throw postgresError("CONTRACT.IDENTIFIER_INVALID", "Identifier cannot be empty", { meta: {
+		value: identifier,
+		context: "identifier"
+	} });
+	if (identifier.includes("\0")) throw postgresError("CONTRACT.IDENTIFIER_INVALID", "Identifier cannot contain null bytes", { meta: {
+		value: identifier.replace(/\0/g, "\\0"),
+		context: "identifier"
+	} });
 	if (identifier.length > MAX_IDENTIFIER_LENGTH) console.warn(`Identifier "${identifier.slice(0, 20)}..." exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`);
 	return `"${identifier.replace(/"/g, "\"\"")}"`;
 }
@@ -46,10 +43,13 @@ function quoteIdentifier(identifier) {
 * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
 * Backslashes are treated as literal characters, not escape sequences.
 *
-* @throws {SqlEscapeError} If the value contains null bytes
+* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value contains null bytes
 */
 function escapeLiteral(value) {
-	if (value.includes("\0")) throw new SqlEscapeError("Literal value cannot contain null bytes", value.replace(/\0/g, "\\0"), "literal");
+	if (value.includes("\0")) throw postgresError("CONTRACT.IDENTIFIER_INVALID", "Literal value cannot contain null bytes", { meta: {
+		value: value.replace(/\0/g, "\\0"),
+		context: "literal"
+	} });
 	return value.replace(/'/g, "''");
 }
 /**
@@ -76,12 +76,15 @@ function quoteQualifiedName(name) {
 *
 * @param value - The enum value to validate
 * @param enumTypeName - Name of the enum type (for error messages)
-* @throws {SqlEscapeError} If the value exceeds the maximum length
+* @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value exceeds the maximum length
 */
 function validateEnumValueLength(value, enumTypeName) {
-	if (new TextEncoder().encode(value).length > MAX_IDENTIFIER_LENGTH) throw new SqlEscapeError(`Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-byte label limit`, value, "literal");
+	if (new TextEncoder().encode(value).length > MAX_IDENTIFIER_LENGTH) throw postgresError("CONTRACT.IDENTIFIER_INVALID", `Enum value "${value.slice(0, 20)}..." for type "${enumTypeName}" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-byte label limit`, { meta: {
+		value,
+		context: "enum-label"
+	} });
 }
 //#endregion
-export { quoteQualifiedName as a, quoteIdentifier as i, escapeLiteral as n, validateEnumValueLength as o, qualifyName as r, SqlEscapeError as t };
+export { validateEnumValueLength as a, quoteQualifiedName as i, qualifyName as n, quoteIdentifier as r, escapeLiteral as t };
 
-//# sourceMappingURL=sql-utils-SU4FDvIV.mjs.map
+//# sourceMappingURL=sql-utils-B2lzkKfP.mjs.map

package/dist/sql-utils-B2lzkKfP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-utils-B2lzkKfP.mjs","names":[],"sources":["../src/core/sql-utils.ts"],"sourcesContent":["/**\n * Shared SQL utility functions for the Postgres target.\n *\n * These functions handle safe SQL identifier and literal escaping\n * with security validations to prevent injection and encoding issues.\n *\n * They live in `target-postgres` because both the control adapter (used at\n * emit time) and the runtime adapter (used at execute time) need the same\n * escaping/validation behavior, and the target package is the natural shared\n * home that both adapters can depend on without crossing planes.\n */\n\nimport { postgresError } from './errors';\n\nconst MAX_IDENTIFIER_LENGTH = 63;\n\n/**\n * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).\n *\n * Security validations:\n * - Rejects null bytes which could cause truncation or unexpected behavior\n * - Rejects empty identifiers\n * - Warns on identifiers exceeding PostgreSQL's 63-character limit\n *\n * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the identifier contains null bytes or is empty\n */\nexport function quoteIdentifier(identifier: string): string {\n  if (identifier.length === 0) {\n    throw postgresError('CONTRACT.IDENTIFIER_INVALID', 'Identifier cannot be empty', {\n      meta: { value: identifier, context: 'identifier' },\n    });\n  }\n  if (identifier.includes('\\0')) {\n    throw postgresError('CONTRACT.IDENTIFIER_INVALID', 'Identifier cannot contain null bytes', {\n      meta: { value: identifier.replace(/\\0/g, '\\\\0'), context: 'identifier' },\n    });\n  }\n  if (identifier.length > MAX_IDENTIFIER_LENGTH) {\n    console.warn(\n      `Identifier \"${identifier.slice(0, 20)}...\" exceeds PostgreSQL's ${MAX_IDENTIFIER_LENGTH}-character limit and will be truncated`,\n    );\n  }\n  return `\"${identifier.replace(/\"/g, '\"\"')}\"`;\n}\n\n/**\n * Escapes a string literal for safe use in SQL statements.\n *\n * Security validations:\n * - Rejects null bytes which could cause truncation or unexpected behavior\n *\n * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).\n * Backslashes are treated as literal characters, not escape sequences.\n *\n * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value contains null bytes\n */\nexport function escapeLiteral(value: string): string {\n  if (value.includes('\\0')) {\n    throw postgresError('CONTRACT.IDENTIFIER_INVALID', 'Literal value cannot contain null bytes', {\n      meta: { value: value.replace(/\\0/g, '\\\\0'), context: 'literal' },\n    });\n  }\n  return value.replace(/'/g, \"''\");\n}\n\n/**\n * Builds a qualified name (schema.object) with proper quoting.\n */\nexport function qualifyName(schemaName: string, objectName: string): string {\n  return `${quoteIdentifier(schemaName)}.${quoteIdentifier(objectName)}`;\n}\n\n/**\n * Quotes a possibly dot-qualified name segment-by-segment:\n * `order_status` -> `\"order_status\"`, `auth.aal_level` -> `\"auth\".\"aal_level\"`.\n * A single-segment name round-trips to exactly {@link quoteIdentifier}; whole-\n * string quoting (`\"auth.aal_level\"`) would be one wrong identifier.\n */\nexport function quoteQualifiedName(name: string): string {\n  return name\n    .split('.')\n    .map((segment) => quoteIdentifier(segment))\n    .join('.');\n}\n\n/**\n * Validates that an enum value doesn't exceed PostgreSQL's label length limit.\n *\n * PostgreSQL enum labels have a maximum length of NAMEDATALEN-1 (63 bytes by default).\n * Unlike identifiers, enum labels that exceed this limit cause an error rather than\n * silent truncation.\n *\n * @param value - The enum value to validate\n * @param enumTypeName - Name of the enum type (for error messages)\n * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value exceeds the maximum length\n */\nexport function validateEnumValueLength(value: string, enumTypeName: string): void {\n  if (new TextEncoder().encode(value).length > MAX_IDENTIFIER_LENGTH) {\n    throw postgresError(\n      'CONTRACT.IDENTIFIER_INVALID',\n      `Enum value \"${value.slice(0, 20)}...\" for type \"${enumTypeName}\" exceeds PostgreSQL's ` +\n        `${MAX_IDENTIFIER_LENGTH}-byte label limit`,\n      { meta: { value, context: 'enum-label' } },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,MAAM,wBAAwB;;;;;;;;;;;AAY9B,SAAgB,gBAAgB,YAA4B;CAC1D,IAAI,WAAW,WAAW,GACxB,MAAM,cAAc,+BAA+B,8BAA8B,EAC/E,MAAM;EAAE,OAAO;EAAY,SAAS;CAAa,EACnD,CAAC;CAEH,IAAI,WAAW,SAAS,IAAI,GAC1B,MAAM,cAAc,+BAA+B,wCAAwC,EACzF,MAAM;EAAE,OAAO,WAAW,QAAQ,OAAO,KAAK;EAAG,SAAS;CAAa,EACzE,CAAC;CAEH,IAAI,WAAW,SAAS,uBACtB,QAAQ,KACN,eAAe,WAAW,MAAM,GAAG,EAAE,EAAE,4BAA4B,sBAAsB,uCAC3F;CAEF,OAAO,IAAI,WAAW,QAAQ,MAAM,MAAI,EAAE;AAC5C;;;;;;;;;;;;AAaA,SAAgB,cAAc,OAAuB;CACnD,IAAI,MAAM,SAAS,IAAI,GACrB,MAAM,cAAc,+BAA+B,2CAA2C,EAC5F,MAAM;EAAE,OAAO,MAAM,QAAQ,OAAO,KAAK;EAAG,SAAS;CAAU,EACjE,CAAC;CAEH,OAAO,MAAM,QAAQ,MAAM,IAAI;AACjC;;;;AAKA,SAAgB,YAAY,YAAoB,YAA4B;CAC1E,OAAO,GAAG,gBAAgB,UAAU,EAAE,GAAG,gBAAgB,UAAU;AACrE;;;;;;;AAQA,SAAgB,mBAAmB,MAAsB;CACvD,OAAO,KACJ,MAAM,GAAG,CAAC,CACV,KAAK,YAAY,gBAAgB,OAAO,CAAC,CAAC,CAC1C,KAAK,GAAG;AACb;;;;;;;;;;;;AAaA,SAAgB,wBAAwB,OAAe,cAA4B;CACjF,IAAI,IAAI,YAAY,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,SAAS,uBAC3C,MAAM,cACJ,+BACA,eAAe,MAAM,MAAM,GAAG,EAAE,EAAE,iBAAiB,aAAa,yBAC3D,sBAAsB,oBAC3B,EAAE,MAAM;EAAE;EAAO,SAAS;CAAa,EAAE,CAC3C;AAEJ"}

package/dist/sql-utils.d.mts

@@ -10,11 +10,6 @@
  * escaping/validation behavior, and the target package is the natural shared
  * home that both adapters can depend on without crossing planes.
  */
-declare class SqlEscapeError extends Error {
-  readonly value: string;
-  readonly kind: 'identifier' | 'literal';
-  constructor(message: string, value: string, kind: 'identifier' | 'literal');
-}
 /**
  * Validates and quotes a PostgreSQL identifier (table, column, type, schema names).
  *
@@ -23,7 +18,7 @@ declare class SqlEscapeError extends Error {
  * - Rejects empty identifiers
  * - Warns on identifiers exceeding PostgreSQL's 63-character limit
  *
- * @throws {SqlEscapeError} If the identifier contains null bytes or is empty
+ * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the identifier contains null bytes or is empty
  */
 declare function quoteIdentifier(identifier: string): string;
 /**
@@ -35,7 +30,7 @@ declare function quoteIdentifier(identifier: string): string;
  * Note: This assumes PostgreSQL's `standard_conforming_strings` is ON (default since PG 9.1).
  * Backslashes are treated as literal characters, not escape sequences.
  *
- * @throws {SqlEscapeError} If the value contains null bytes
+ * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value contains null bytes
  */
 declare function escapeLiteral(value: string): string;
 /**
@@ -58,9 +53,9 @@ declare function quoteQualifiedName(name: string): string;
  *
  * @param value - The enum value to validate
  * @param enumTypeName - Name of the enum type (for error messages)
- * @throws {SqlEscapeError} If the value exceeds the maximum length
+ * @throws `CONTRACT.IDENTIFIER_INVALID` structured error If the value exceeds the maximum length
  */
 declare function validateEnumValueLength(value: string, enumTypeName: string): void;
 //#endregion
-export { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier, quoteQualifiedName, validateEnumValueLength };
+export { escapeLiteral, qualifyName, quoteIdentifier, quoteQualifiedName, validateEnumValueLength };
 //# sourceMappingURL=sql-utils.d.mts.map

package/dist/sql-utils.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-utils.d.mts","names":[],"sources":["../src/core/sql-utils.ts"],"mappings":";;;;;;;;;;;;cAYa,uBAAuB;WAGhB;WACA;cAFhB,iBACgB,eACA;;;;;;;;;;;;iBAmBJ,gBAAgB;;;;;;;;;;;;iBA8BhB,cAAc;;;;iBAcd,YAAY,oBAAoB;;;;;;;iBAUhC,mBAAmB;;;;;;;;;;;;iBAkBnB,wBAAwB,eAAe"}
+{"version":3,"file":"sql-utils.d.mts","names":[],"sources":["../src/core/sql-utils.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;iBA0BgB,gBAAgB;;;;;;;;;;;;iBA8BhB,cAAc;;;;iBAYd,YAAY,oBAAoB;;;;;;;iBAUhC,mBAAmB;;;;;;;;;;;;iBAkBnB,wBAAwB,eAAe"}

package/dist/sql-utils.mjs

@@ -1,2 +1,2 @@
-import { a as quoteQualifiedName, i as quoteIdentifier, n as escapeLiteral, o as validateEnumValueLength, r as qualifyName, t as SqlEscapeError } from "./sql-utils-SU4FDvIV.mjs";
-export { SqlEscapeError, escapeLiteral, qualifyName, quoteIdentifier, quoteQualifiedName, validateEnumValueLength };
+import { a as validateEnumValueLength, i as quoteQualifiedName, n as qualifyName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-B2lzkKfP.mjs";
+export { escapeLiteral, qualifyName, quoteIdentifier, quoteQualifiedName, validateEnumValueLength };

package/dist/types.mjs

@@ -1,5 +1,5 @@
 import { t as PostgresNativeEnum } from "./postgres-native-enum-BwVNf0Ku.mjs";
-import { _ as PostgresRlsEnablement, g as PostgresRlsPolicy, i as postgresCreateNamespace, m as PostgresRole, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-CewLYHB7.mjs";
+import { _ as PostgresRlsEnablement, g as PostgresRlsPolicy, i as postgresCreateNamespace, m as PostgresRole, n as PostgresUnboundSchema, r as isPostgresSchema, t as PostgresSchema } from "./postgres-schema-CTplQZDK.mjs";
 import { n as PostgresNativeEnumSchemaNode, r as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-D6LvInCe.mjs";
 import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-bg32e7I-.mjs";
 export { PostgresDatabaseSchemaNode, PostgresNamespaceSchemaNode, PostgresNativeEnum, PostgresNativeEnumSchemaNode, PostgresPolicySchemaNode, PostgresRlsEnablement, PostgresRlsPolicy, PostgresRole, PostgresRoleSchemaNode, PostgresSchema, PostgresSchemaNodeKind, PostgresTableSchemaNode, PostgresUnboundSchema, isPostgresSchema, postgresCreateNamespace };

package/package.json

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

package/src/contract-free/ddl.ts

@@ -2,14 +2,18 @@ import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-
 import {
   AddColumnAction,
   type AnyAlterTableAction,
+  type DdlIndexElements,
   DropDefaultAction,
+  PostgresAlterIndexRename,
   PostgresAlterPolicyRename,
   PostgresAlterTable,
+  PostgresCreateIndex,
   PostgresCreatePolicy,
   PostgresCreateSchema,
   PostgresCreateTable,
   PostgresCreateType,
   PostgresDisableRowLevelSecurity,
+  PostgresDropIndex,
   PostgresDropPolicy,
   PostgresDropType,
   type RlsPolicyOperation,
@@ -149,6 +153,49 @@ export function alterPolicyRename(options: {
   return new PostgresAlterPolicyRename(options);
 }
 
+/**
+ * Build a Postgres `CREATE [UNIQUE] INDEX` DDL node. Identifiers (`schema`,
+ * `table`, `name`, column elements, `type`, option keys) are quoted by the
+ * renderer; the `expression` element list and the `where` predicate are
+ * inserted verbatim (opaque SQL). An absent `schema` renders the object
+ * names unqualified (the unbound namespace).
+ */
+export function createIndex(options: {
+  readonly schema: string | undefined;
+  readonly table: string;
+  readonly name: string;
+  readonly unique: boolean;
+  readonly elements: DdlIndexElements;
+  readonly type: string | undefined;
+  readonly options: Record<string, unknown> | undefined;
+  readonly where: string | undefined;
+}): PostgresCreateIndex {
+  return new PostgresCreateIndex(options);
+}
+
+/**
+ * Build a Postgres `DROP INDEX` DDL node. The index name (and optional
+ * schema) are quoted by the renderer.
+ */
+export function dropIndex(options: {
+  readonly schema: string | undefined;
+  readonly name: string;
+}): PostgresDropIndex {
+  return new PostgresDropIndex(options);
+}
+
+/**
+ * Build a Postgres `ALTER INDEX … RENAME TO` DDL node. Identifiers are
+ * quoted by the renderer.
+ */
+export function alterIndexRename(options: {
+  readonly schema: string | undefined;
+  readonly from: string;
+  readonly to: string;
+}): PostgresAlterIndexRename {
+  return new PostgresAlterIndexRename(options);
+}
+
 /**
  * Build a Postgres `ALTER TABLE … DISABLE ROW LEVEL SECURITY` DDL node.
  * Identifiers (`schema`, `table`) are quoted by the renderer.

package/src/core/authoring.ts

@@ -22,10 +22,16 @@ import type {
   ResolvedPslModelRefs,
 } from '@prisma-next/sql-contract/entity-handle-lowering-hook';
 import type { SqlValueSetDerivingEntityTypeOutput } from '@prisma-next/sql-contract/value-set-derivation-hook';
+import {
+  assertWireNamePrefixLength,
+  formatWireName,
+  normalizeSqlBody,
+} from '@prisma-next/sql-schema-ir/naming';
 import { assertDefined } from '@prisma-next/utils/assertions';
 import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PG_ENUM_CODEC_ID } from './codec-ids';
+import { postgresError } from './errors';
 import { PostgresNativeEnum } from './postgres-native-enum';
 import { PostgresRlsEnablement, type PostgresRlsEnablementInput } from './postgres-rls-enablement';
 import { PostgresRlsPolicy, type RlsPolicyOperation } from './postgres-rls-policy';
@@ -36,12 +42,7 @@ import {
   PostgresRlsPolicySchema,
   PostgresRoleSchema,
 } from './postgres-validators';
-import {
-  computeContentHash,
-  normalizePredicate,
-  POLICY_OPERATION_PREDICATES,
-} from './rls/canonicalize';
-import { formatRlsPolicyWireName } from './rls/wire-name';
+import { computeContentHash, POLICY_OPERATION_PREDICATES } from './rls/canonicalize';
 
 /**
  * `pg.enum(<ref>)` registers as an ordinary type constructor whose sole
@@ -153,10 +154,10 @@ function buildRlsPolicyEntity(input: {
   readonly withCheck?: string;
 }): PostgresRlsPolicy {
   const wireHash = computeContentHash({
-    ...ifDefined('using', input.using !== undefined ? normalizePredicate(input.using) : undefined),
+    ...ifDefined('using', input.using !== undefined ? normalizeSqlBody(input.using) : undefined),
     ...ifDefined(
       'withCheck',
-      input.withCheck !== undefined ? normalizePredicate(input.withCheck) : undefined,
+      input.withCheck !== undefined ? normalizeSqlBody(input.withCheck) : undefined,
     ),
     roles: input.roles,
     operation: input.operation,
@@ -164,7 +165,7 @@ function buildRlsPolicyEntity(input: {
   });
 
   return new PostgresRlsPolicy({
-    name: formatRlsPolicyWireName(input.prefix, wireHash),
+    name: formatWireName(input.prefix, wireHash),
     prefix: input.prefix,
     tableName: input.tableName,
     namespaceId: input.namespaceId,
@@ -683,12 +684,6 @@ export const postgresAuthoringFieldPresets = {
   },
 } as const satisfies AuthoringFieldNamespace;
 
-/**
- * Postgres identifiers cap at 63 characters and the wire name appends a
- * 9-character `_<8hex>` suffix, so the authored prefix is bounded at 54.
- */
-const RLS_POLICY_PREFIX_MAX_LENGTH = 54;
-
 interface RlsRoleHandleShape {
   readonly entityKind: 'role';
   readonly name: string;
@@ -723,12 +718,16 @@ function requireLocalTarget(
     return { namespaceId: target.namespaceId, tableName: target.tableName };
   }
   if (target !== undefined && target.kind === 'cross-space') {
-    throw new Error(
+    throw postgresError(
+      'CONTRACT.POLICY_INVALID',
       `defineContract: ${subject} targets model "${target.modelName ?? target.tableName}", which lives in another contract space. Policies and rlsEnabled entries must target a model declared in this contract.`,
+      { meta: { model: target.modelName ?? target.tableName, reason: 'cross-space-target' } },
     );
   }
-  throw new Error(
+  throw postgresError(
+    'CONTRACT.MODEL_UNKNOWN',
     `defineContract: ${subject} targets model "${target?.modelName ?? '<anonymous>'}", which is not in the contract's models. Add the model to \`models\`.`,
+    { meta: { model: target?.modelName ?? '<anonymous>' } },
   );
 }
 
@@ -780,8 +779,10 @@ export function postgresLowerEntityHandles(
           'role handles are constructed only by the postgres contract-builder role() constructor, which enforces this shape'
         >(handle);
         if (roles.has(roleHandle.name)) {
-          throw new Error(
+          throw postgresError(
+            'CONTRACT.ROLE_INVALID',
             `defineContract: role "${roleHandle.name}" is declared more than once in the entities list.`,
+            { meta: { role: roleHandle.name, reason: 'duplicate' } },
           );
         }
         // Roles are cluster-scoped in Postgres, so they always land in the
@@ -804,8 +805,10 @@ export function postgresLowerEntityHandles(
         break;
       }
       default:
-        throw new Error(
+        throw postgresError(
+          'CONTRACT.ENTITY_KIND_INVALID',
           `defineContract: the postgres pack does not lower "${handle.entityKind}" handles from the entities list.`,
+          { meta: { entityKind: handle.entityKind } },
         );
     }
   }
@@ -815,22 +818,28 @@ export function postgresLowerEntityHandles(
 
   for (const { handle: policy, refs } of policies) {
     const prefix = policy.name;
-    if (prefix.length > RLS_POLICY_PREFIX_MAX_LENGTH) {
-      throw new Error(
-        `defineContract: policy prefix "${prefix}" exceeds the ${RLS_POLICY_PREFIX_MAX_LENGTH}-character maximum (Postgres identifiers cap at 63 characters and the wire name appends a 9-character hash suffix).`,
-      );
-    }
+    assertWireNamePrefixLength(prefix, 'defineContract: policy prefix');
     const coordinate = requireLocalTarget(refs, `policy "${prefix}"`);
     if (!enablements.has(coordinateKey(coordinate))) {
       const target = refs['target'];
-      throw new Error(
+      throw postgresError(
+        'CONTRACT.POLICY_INVALID',
         `defineContract: policy "${prefix}" targets model "${target?.modelName ?? coordinate.tableName}", whose table is not RLS-enabled. Add rlsEnabled(<model>) to the entities list.`,
+        {
+          meta: {
+            prefix,
+            model: target?.modelName ?? coordinate.tableName,
+            reason: 'target-not-rls-enabled',
+          },
+        },
       );
     }
     const prefixKey = `${coordinate.namespaceId} ${prefix}`;
     if (seenPrefixes.has(prefixKey)) {
-      throw new Error(
+      throw postgresError(
+        'CONTRACT.POLICY_INVALID',
         `defineContract: policy prefix "${prefix}" is declared more than once in namespace "${coordinate.namespaceId}". Policy prefixes must be unique per namespace.`,
+        { meta: { prefix, namespaceId: coordinate.namespaceId, reason: 'duplicate-prefix' } },
       );
     }
     seenPrefixes.add(prefixKey);