@prisma-next/target-postgres 0.16.0-dev.32 → 0.16.0-dev.34

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

@@ -1,4 +1,4 @@
-import { n as postgresError } from "./errors-DBSNx7EJ.mjs";
+import { n as postgresError } from "./errors-l1usFTuz.mjs";
 //#region src/core/sql-utils.ts
 /**
 * Shared SQL utility functions for the Postgres target.
@@ -87,4 +87,4 @@ function validateEnumValueLength(value, enumTypeName) {
 //#endregion
 export { validateEnumValueLength as a, quoteQualifiedName as i, qualifyName as n, quoteIdentifier as r, escapeLiteral as t };
 
-//# sourceMappingURL=sql-utils-B2lzkKfP.mjs.map
+//# sourceMappingURL=sql-utils-CuKSscKn.mjs.map

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

@@ -1 +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"}
+{"version":3,"file":"sql-utils-CuKSscKn.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.mjs

@@ -1,2 +1,2 @@
-import { a as validateEnumValueLength, i as quoteQualifiedName, n as qualifyName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-B2lzkKfP.mjs";
+import { a as validateEnumValueLength, i as quoteQualifiedName, n as qualifyName, r as quoteIdentifier, t as escapeLiteral } from "./sql-utils-CuKSscKn.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-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";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-DqjHPN11.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-DAhXnFac.mjs";
+import { n as PostgresNativeEnumSchemaNode, r as PostgresSchemaNodeKind, t as PostgresTableSchemaNode } from "./postgres-table-schema-node-DXzwiu16.mjs";
+import { i as PostgresDatabaseSchemaNode, n as PostgresPolicySchemaNode, r as PostgresNamespaceSchemaNode, t as PostgresRoleSchemaNode } from "./postgres-role-schema-node-DOkim7QI.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.32",
+  "version": "0.16.0-dev.34",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Postgres target pack for Prisma Next",
   "dependencies": {
-    "@prisma-next/cli": "0.16.0-dev.32",
-    "@prisma-next/contract": "0.16.0-dev.32",
-    "@prisma-next/errors": "0.16.0-dev.32",
-    "@prisma-next/family-sql": "0.16.0-dev.32",
-    "@prisma-next/framework-components": "0.16.0-dev.32",
-    "@prisma-next/migration-tools": "0.16.0-dev.32",
-    "@prisma-next/psl-parser": "0.16.0-dev.32",
-    "@prisma-next/sql-contract": "0.16.0-dev.32",
-    "@prisma-next/sql-errors": "0.16.0-dev.32",
-    "@prisma-next/sql-operations": "0.16.0-dev.32",
-    "@prisma-next/sql-relational-core": "0.16.0-dev.32",
-    "@prisma-next/sql-schema-ir": "0.16.0-dev.32",
-    "@prisma-next/ts-render": "0.16.0-dev.32",
-    "@prisma-next/utils": "0.16.0-dev.32",
+    "@prisma-next/cli": "0.16.0-dev.34",
+    "@prisma-next/contract": "0.16.0-dev.34",
+    "@prisma-next/errors": "0.16.0-dev.34",
+    "@prisma-next/family-sql": "0.16.0-dev.34",
+    "@prisma-next/framework-components": "0.16.0-dev.34",
+    "@prisma-next/migration-tools": "0.16.0-dev.34",
+    "@prisma-next/psl-parser": "0.16.0-dev.34",
+    "@prisma-next/sql-contract": "0.16.0-dev.34",
+    "@prisma-next/sql-errors": "0.16.0-dev.34",
+    "@prisma-next/sql-operations": "0.16.0-dev.34",
+    "@prisma-next/sql-relational-core": "0.16.0-dev.34",
+    "@prisma-next/sql-schema-ir": "0.16.0-dev.34",
+    "@prisma-next/ts-render": "0.16.0-dev.34",
+    "@prisma-next/utils": "0.16.0-dev.34",
     "@standard-schema/spec": "^1.1.0",
     "arktype": "^2.2.2",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@prisma-next/psl-printer": "0.16.0-dev.32",
-    "@prisma-next/sql-contract-psl": "0.16.0-dev.32",
-    "@prisma-next/test-utils": "0.16.0-dev.32",
-    "@prisma-next/tsconfig": "0.16.0-dev.32",
-    "@prisma-next/tsdown": "0.16.0-dev.32",
+    "@prisma-next/psl-printer": "0.16.0-dev.34",
+    "@prisma-next/sql-contract-psl": "0.16.0-dev.34",
+    "@prisma-next/test-utils": "0.16.0-dev.34",
+    "@prisma-next/tsconfig": "0.16.0-dev.34",
+    "@prisma-next/tsdown": "0.16.0-dev.34",
     "tsdown": "0.22.8",
     "typescript": "5.9.3",
     "vitest": "4.1.10"
@@ -48,6 +48,7 @@
     "packs"
   ],
   "exports": {
+    "./codec-descriptor": "./dist/codec-descriptor.mjs",
     "./codec-ids": "./dist/codec-ids.mjs",
     "./codec-types": "./dist/codec-types.mjs",
     "./codecs": "./dist/codecs.mjs",

package/src/core/codec-descriptor.ts

@@ -0,0 +1,318 @@
+import type { JsonValue } from '@prisma-next/contract/types';
+import {
+  type AnyCodecDescriptor,
+  type Codec,
+  type CodecDescriptor,
+  CodecDescriptorImpl,
+  type CodecInstanceContext,
+  type CodecMeta,
+  type CodecRef,
+  type CodecTrait,
+  validateCodecTypeParams,
+} from '@prisma-next/framework-components/codec';
+import {
+  CaseExpr,
+  ColumnRef,
+  DerivedTableSource,
+  FunctionSource,
+  JsonArrayAggExpr,
+  LiteralExpr,
+  NativeJsonValueProjection,
+  NullCheckExpr,
+  OrderByItem,
+  type ProjectionExpr,
+  ProjectionItem,
+  SelectAst,
+  SubqueryExpr,
+} from '@prisma-next/sql-relational-core/ast';
+import { blindCast } from '@prisma-next/utils/casts';
+import { structuredError } from '@prisma-next/utils/structured-error';
+
+const POSTGRES_CODEC_DESCRIPTOR_KIND = 'postgres-codec' as const;
+const ARRAY_INPUT_ALIAS = 'array_input';
+const ARRAY_ELEMENT_ALIAS = 'array_element';
+const ARRAY_VALUE_COLUMN = 'value';
+const ARRAY_ORDINALITY_COLUMN = 'ordinality';
+
+export interface AnyPostgresCodecDescriptor extends AnyCodecDescriptor {
+  readonly descriptorKind: typeof POSTGRES_CODEC_DESCRIPTOR_KIND;
+  nativeTypeFor(ref: CodecRef): string;
+  projectJson(expression: ProjectionExpr, ref: CodecRef): ProjectionExpr;
+}
+
+export abstract class PostgresCodecDescriptor<P = void>
+  extends CodecDescriptorImpl<P>
+  implements AnyPostgresCodecDescriptor
+{
+  readonly descriptorKind = POSTGRES_CODEC_DESCRIPTOR_KIND;
+
+  protected abstract nativeType(params: P): string;
+  protected abstract jsonProjection(expression: ProjectionExpr, params: P): ProjectionExpr;
+
+  protected jsonArrayProjection(expression: ProjectionExpr, params: P): ProjectionExpr {
+    const boundArray = ColumnRef.of(ARRAY_INPUT_ALIAS, ARRAY_VALUE_COLUMN);
+    const element = ColumnRef.of(ARRAY_ELEMENT_ALIAS, ARRAY_VALUE_COLUMN);
+    const ordinality = ColumnRef.of(ARRAY_ELEMENT_ALIAS, ARRAY_ORDINALITY_COLUMN);
+    const projectedElement = CaseExpr.of(
+      [{ condition: NullCheckExpr.isNull(element), value: LiteralExpr.of(null) }],
+      this.jsonProjection(element, params),
+    );
+    const aggregate = JsonArrayAggExpr.of(
+      new NativeJsonValueProjection(projectedElement),
+      'emptyArray',
+      [OrderByItem.asc(ordinality)],
+    );
+    const aggregateQuery = SelectAst.from(
+      FunctionSource.of('unnest', [boundArray], {
+        alias: ARRAY_ELEMENT_ALIAS,
+        columnAliases: [ARRAY_VALUE_COLUMN, ARRAY_ORDINALITY_COLUMN],
+      }).withOrdinality(),
+    ).withProjection([ProjectionItem.of(ARRAY_VALUE_COLUMN, aggregate)]);
+    const arrayResult = CaseExpr.of(
+      [{ condition: NullCheckExpr.isNull(boundArray), value: LiteralExpr.of(null) }],
+      SubqueryExpr.of(aggregateQuery),
+    );
+    const inputBinding = SelectAst.noFrom().withProjection([
+      ProjectionItem.of(ARRAY_VALUE_COLUMN, expression),
+    ]);
+
+    return SubqueryExpr.of(
+      SelectAst.from(DerivedTableSource.as(ARRAY_INPUT_ALIAS, inputBinding)).withProjection([
+        ProjectionItem.of(ARRAY_VALUE_COLUMN, arrayResult),
+      ]),
+    );
+  }
+
+  nativeTypeFor(ref: CodecRef): string {
+    return this.nativeType(this.validateParams(ref));
+  }
+
+  projectJson(expression: ProjectionExpr, ref: CodecRef): ProjectionExpr {
+    const params = this.validateParams(ref);
+    return ref.many === true
+      ? this.jsonArrayProjection(expression, params)
+      : this.jsonProjection(expression, params);
+  }
+
+  private validateParams(ref: CodecRef): P {
+    return blindCast<
+      P,
+      'validateCodecTypeParams synchronously validates this descriptor schema before the typed hook'
+    >(validateCodecTypeParams(this, ref));
+  }
+}
+
+type DescriptorParams<D extends AnyCodecDescriptor> =
+  D extends CodecDescriptor<infer P> ? P : never;
+
+export interface PostgresCodecOptions<P> {
+  readonly nativeType: (params: P) => string;
+  readonly jsonProjection: (expression: ProjectionExpr, params: P) => ProjectionExpr;
+  readonly jsonArrayProjection?: (expression: ProjectionExpr, params: P) => ProjectionExpr;
+}
+
+export type AdaptedPostgresCodecDescriptor<D extends AnyCodecDescriptor> = Pick<
+  D,
+  keyof CodecDescriptor<DescriptorParams<D>>
+> &
+  Pick<AnyPostgresCodecDescriptor, 'descriptorKind' | 'nativeTypeFor' | 'projectJson'>;
+
+class PostgresCodecDescriptorAdapter<D extends AnyCodecDescriptor> extends PostgresCodecDescriptor<
+  DescriptorParams<D>
+> {
+  override readonly codecId: string;
+  override readonly traits: readonly CodecTrait[];
+  override readonly targetTypes: readonly string[];
+  override readonly paramsSchema: D['paramsSchema'];
+  override readonly metaFor?: (params: DescriptorParams<D>) => CodecMeta | undefined;
+  override readonly renderOutputType?: (params: DescriptorParams<D>) => string | undefined;
+  override readonly renderInputType?: (params: DescriptorParams<D>) => string | undefined;
+  override readonly renderValueLiteral?: (
+    value: JsonValue,
+    side: 'output' | 'input',
+  ) => string | undefined;
+  override readonly factory: (
+    params: DescriptorParams<D>,
+  ) => (ctx: CodecInstanceContext) => Codec<string, readonly CodecTrait[], unknown, unknown>;
+
+  constructor(
+    private readonly descriptor: D,
+    private readonly options: PostgresCodecOptions<DescriptorParams<D>>,
+  ) {
+    super();
+    this.codecId = descriptor.codecId;
+    this.traits = descriptor.traits;
+    this.targetTypes = descriptor.targetTypes;
+    this.paramsSchema = descriptor.paramsSchema;
+    this.factory = (params) => descriptor.factory(params);
+
+    if (descriptor.meta !== undefined) {
+      Object.defineProperty(this, 'meta', {
+        value: descriptor.meta,
+        enumerable: true,
+      });
+    }
+
+    const metaFor = descriptor.metaFor;
+    if (metaFor !== undefined) {
+      this.metaFor = (params) => metaFor.call(descriptor, params);
+    }
+
+    const renderOutputType = descriptor.renderOutputType;
+    if (renderOutputType !== undefined) {
+      this.renderOutputType = (params) => renderOutputType.call(descriptor, params);
+    }
+
+    const renderInputType = descriptor.renderInputType;
+    if (renderInputType !== undefined) {
+      this.renderInputType = (params) => renderInputType.call(descriptor, params);
+    }
+
+    const renderValueLiteral = descriptor.renderValueLiteral;
+    if (renderValueLiteral !== undefined) {
+      this.renderValueLiteral = (value, side) => renderValueLiteral.call(descriptor, value, side);
+    }
+  }
+
+  override get isParameterized(): boolean {
+    return this.descriptor.isParameterized;
+  }
+
+  protected override nativeType(params: DescriptorParams<D>): string {
+    return this.options.nativeType(params);
+  }
+
+  protected override jsonProjection(
+    expression: ProjectionExpr,
+    params: DescriptorParams<D>,
+  ): ProjectionExpr {
+    return this.options.jsonProjection(expression, params);
+  }
+
+  protected override jsonArrayProjection(
+    expression: ProjectionExpr,
+    params: DescriptorParams<D>,
+  ): ProjectionExpr {
+    return this.options.jsonArrayProjection === undefined
+      ? super.jsonArrayProjection(expression, params)
+      : this.options.jsonArrayProjection(expression, params);
+  }
+}
+
+export function postgresCodec<D extends AnyCodecDescriptor>(
+  descriptor: D,
+  options: PostgresCodecOptions<DescriptorParams<D>>,
+): AdaptedPostgresCodecDescriptor<D> {
+  return blindCast<
+    AdaptedPostgresCodecDescriptor<D>,
+    'the adapter delegates every ordinary descriptor member while adding the validated PostgreSQL protocol'
+  >(new PostgresCodecDescriptorAdapter(descriptor, options));
+}
+
+export function definePostgresCodecs<
+  const Descriptors extends readonly AnyPostgresCodecDescriptor[],
+>(descriptors: Descriptors): Descriptors {
+  return descriptors;
+}
+
+export function isPostgresCodecDescriptor(value: unknown): value is AnyPostgresCodecDescriptor {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'descriptorKind' in value &&
+    value.descriptorKind === POSTGRES_CODEC_DESCRIPTOR_KIND &&
+    'codecId' in value &&
+    typeof value.codecId === 'string' &&
+    'traits' in value &&
+    Array.isArray(value.traits) &&
+    'targetTypes' in value &&
+    Array.isArray(value.targetTypes) &&
+    value.targetTypes.every((targetType) => typeof targetType === 'string') &&
+    'paramsSchema' in value &&
+    isObjectLike(value.paramsSchema) &&
+    '~standard' in value.paramsSchema &&
+    isObjectLike(value.paramsSchema['~standard']) &&
+    'validate' in value.paramsSchema['~standard'] &&
+    typeof value.paramsSchema['~standard'].validate === 'function' &&
+    'isParameterized' in value &&
+    typeof value.isParameterized === 'boolean' &&
+    'factory' in value &&
+    typeof value.factory === 'function' &&
+    'nativeTypeFor' in value &&
+    typeof value.nativeTypeFor === 'function' &&
+    'projectJson' in value &&
+    typeof value.projectJson === 'function'
+  );
+}
+
+function isObjectLike(value: unknown): value is object {
+  return (typeof value === 'object' && value !== null) || typeof value === 'function';
+}
+
+export interface PostgresCodecDescriptorRegistry {
+  descriptorFor(codecId: string): AnyPostgresCodecDescriptor | undefined;
+  values(): IterableIterator<AnyPostgresCodecDescriptor>;
+}
+
+class PostgresCodecDescriptorRegistryImpl implements PostgresCodecDescriptorRegistry {
+  readonly #descriptors: ReadonlyMap<string, AnyPostgresCodecDescriptor>;
+
+  constructor(descriptors: ReadonlyMap<string, AnyPostgresCodecDescriptor>) {
+    this.#descriptors = descriptors;
+    Object.freeze(this);
+  }
+
+  descriptorFor(codecId: string): AnyPostgresCodecDescriptor | undefined {
+    return this.#descriptors.get(codecId);
+  }
+
+  *values(): IterableIterator<AnyPostgresCodecDescriptor> {
+    yield* this.#descriptors.values();
+  }
+}
+
+export function buildPostgresCodecDescriptorRegistry(
+  descriptors: ReadonlyArray<unknown>,
+): PostgresCodecDescriptorRegistry {
+  const byId = new Map<string, AnyPostgresCodecDescriptor>();
+
+  for (const descriptor of descriptors) {
+    if (!isPostgresCodecDescriptor(descriptor)) {
+      const codecId = candidateCodecId(descriptor);
+      throw structuredError(
+        'POSTGRES.CODEC_DESCRIPTOR_INVALID',
+        `Codec descriptor '${codecId}' is not a valid PostgreSQL codec descriptor.`,
+        {
+          why: 'PostgreSQL codec registries require the postgres-codec discriminant and complete target descriptor methods.',
+          fix: 'Extend PostgresCodecDescriptor or adapt a generic descriptor with postgresCodec().',
+          meta: { codecId },
+        },
+      );
+    }
+
+    if (byId.has(descriptor.codecId)) {
+      throw structuredError(
+        'POSTGRES.CODEC_DESCRIPTOR_DUPLICATE',
+        `Duplicate PostgreSQL codec descriptor id '${descriptor.codecId}'.`,
+        {
+          why: 'Each codecId must resolve to exactly one PostgreSQL descriptor during registry composition.',
+          fix: 'Remove the duplicate target, adapter, or extension contribution.',
+          meta: { codecId: descriptor.codecId },
+        },
+      );
+    }
+
+    byId.set(descriptor.codecId, descriptor);
+  }
+
+  return new PostgresCodecDescriptorRegistryImpl(byId);
+}
+
+function candidateCodecId(value: unknown): string {
+  return typeof value === 'object' &&
+    value !== null &&
+    'codecId' in value &&
+    typeof value.codecId === 'string'
+    ? value.codecId
+    : '<unknown>';
+}

package/src/core/codec-type-map.ts

@@ -8,14 +8,6 @@
  */
 
 import type { ExtractCodecTypes } from '@prisma-next/sql-relational-core/ast';
-import {
-  sqlCharDescriptor,
-  sqlFloatDescriptor,
-  sqlIntDescriptor,
-  sqlTextDescriptor,
-  sqlTimestampDescriptor,
-  sqlVarcharDescriptor,
-} from '@prisma-next/sql-relational-core/ast';
 import {
   pgBitDescriptor,
   pgBoolDescriptor,
@@ -43,15 +35,21 @@ import {
   pgUuidDescriptor,
   pgVarbitDescriptor,
   pgVarcharDescriptor,
+  postgresSqlCharDescriptor,
+  postgresSqlFloatDescriptor,
+  postgresSqlIntDescriptor,
+  postgresSqlTextDescriptor,
+  postgresSqlTimestampDescriptor,
+  postgresSqlVarcharDescriptor,
 } from './codecs';
 
 export const codecDescriptorMap = {
-  char: sqlCharDescriptor,
-  varchar: sqlVarcharDescriptor,
-  int: sqlIntDescriptor,
-  float: sqlFloatDescriptor,
-  'sql-text': sqlTextDescriptor,
-  'sql-timestamp': sqlTimestampDescriptor,
+  char: postgresSqlCharDescriptor,
+  varchar: postgresSqlVarcharDescriptor,
+  int: postgresSqlIntDescriptor,
+  float: postgresSqlFloatDescriptor,
+  'sql-text': postgresSqlTextDescriptor,
+  'sql-timestamp': postgresSqlTimestampDescriptor,
   text: pgTextDescriptor,
   enum: pgEnumDescriptor,
   character: pgCharDescriptor,