@prisma-next/adapter-postgres 0.8.0 → 0.9.0-dev.2

package/dist/descriptor-meta-ZIv9PU-5.mjs

@@ -0,0 +1,314 @@
+import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
+import { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_BYTEA_CODEC_ID, PG_CHAR_CODEC_ID, PG_FLOAT4_CODEC_ID, PG_FLOAT8_CODEC_ID, PG_FLOAT_CODEC_ID, PG_INT2_CODEC_ID, PG_INT4_CODEC_ID, PG_INT8_CODEC_ID, PG_INTERVAL_CODEC_ID, PG_INT_CODEC_ID, PG_JSONB_CODEC_ID, PG_JSON_CODEC_ID, PG_NUMERIC_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_VARBIT_CODEC_ID, PG_VARCHAR_CODEC_ID, SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC_ID, SQL_TIMESTAMP_CODEC_ID, SQL_VARCHAR_CODEC_ID } from "@prisma-next/target-postgres/codec-ids";
+import { buildOperation, toExpr } from "@prisma-next/sql-relational-core/expression";
+//#region src/core/descriptor-meta.ts
+/** Creates a type import spec for codec types */
+const codecTypeImport = (named) => ({
+	package: "@prisma-next/target-postgres/codec-types",
+	named,
+	alias: named
+});
+function isPositiveInteger(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value > 0;
+}
+function isNonNegativeInteger(value) {
+	return typeof value === "number" && Number.isFinite(value) && Number.isInteger(value) && value >= 0;
+}
+function expandLength({ nativeType, typeParams }) {
+	if (!typeParams || !("length" in typeParams)) return nativeType;
+	const length = typeParams["length"];
+	if (!isPositiveInteger(length)) throw new Error(`Invalid "length" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(length)}`);
+	return `${nativeType}(${length})`;
+}
+function expandPrecision({ nativeType, typeParams }) {
+	if (!typeParams || !("precision" in typeParams)) return nativeType;
+	const precision = typeParams["precision"];
+	if (!isPositiveInteger(precision)) throw new Error(`Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`);
+	return `${nativeType}(${precision})`;
+}
+function expandNumeric({ nativeType, typeParams }) {
+	const hasPrecision = typeParams && "precision" in typeParams;
+	const hasScale = typeParams && "scale" in typeParams;
+	if (!hasPrecision && !hasScale) return nativeType;
+	if (!hasPrecision && hasScale) throw new Error(`Invalid type parameters for "${nativeType}": "scale" requires "precision" to be specified`);
+	if (hasPrecision) {
+		const precision = typeParams["precision"];
+		if (!isPositiveInteger(precision)) throw new Error(`Invalid "precision" type parameter for "${nativeType}": expected a positive integer, got ${JSON.stringify(precision)}`);
+		if (hasScale) {
+			const scale = typeParams["scale"];
+			if (!isNonNegativeInteger(scale)) throw new Error(`Invalid "scale" type parameter for "${nativeType}": expected a non-negative integer, got ${JSON.stringify(scale)}`);
+			return `${nativeType}(${precision},${scale})`;
+		}
+		return `${nativeType}(${precision})`;
+	}
+	return nativeType;
+}
+const lengthHooks = { expandNativeType: expandLength };
+const precisionHooks = { expandNativeType: expandPrecision };
+const numericHooks = { expandNativeType: expandNumeric };
+const identityHooks = { expandNativeType: ({ nativeType }) => nativeType };
+function postgresQueryOperations() {
+	return { ilike: {
+		self: { traits: ["textual"] },
+		impl: (self, pattern) => {
+			return buildOperation({
+				method: "ilike",
+				args: [toExpr(self), toExpr(pattern, { codecId: PG_TEXT_CODEC_ID })],
+				returns: {
+					codecId: PG_BOOL_CODEC_ID,
+					nullable: false
+				},
+				lowering: {
+					targetFamily: "sql",
+					strategy: "infix",
+					template: "{{self}} ILIKE {{arg0}}"
+				}
+			});
+		}
+	} };
+}
+const postgresAdapterDescriptorMeta = {
+	kind: "adapter",
+	familyId: "sql",
+	targetId: "postgres",
+	id: "postgres",
+	version: "0.0.1",
+	capabilities: {
+		postgres: {
+			orderBy: true,
+			limit: true,
+			lateral: true,
+			jsonAgg: true,
+			returning: true
+		},
+		sql: {
+			enums: true,
+			returning: true,
+			defaultInInsert: true
+		}
+	},
+	types: {
+		codecTypes: {
+			codecDescriptors: Array.from(postgresCodecRegistry.values()),
+			import: {
+				package: "@prisma-next/target-postgres/codec-types",
+				named: "CodecTypes",
+				alias: "PgTypes"
+			},
+			typeImports: [
+				{
+					package: "@prisma-next/target-postgres/codec-types",
+					named: "JsonValue",
+					alias: "JsonValue"
+				},
+				codecTypeImport("Char"),
+				codecTypeImport("Varchar"),
+				codecTypeImport("Numeric"),
+				codecTypeImport("Bit"),
+				codecTypeImport("VarBit"),
+				codecTypeImport("Timestamp"),
+				codecTypeImport("Timestamptz"),
+				codecTypeImport("Time"),
+				codecTypeImport("Timetz"),
+				codecTypeImport("Interval")
+			],
+			controlPlaneHooks: {
+				[SQL_CHAR_CODEC_ID]: lengthHooks,
+				[SQL_VARCHAR_CODEC_ID]: lengthHooks,
+				[SQL_TIMESTAMP_CODEC_ID]: precisionHooks,
+				[PG_CHAR_CODEC_ID]: lengthHooks,
+				[PG_VARCHAR_CODEC_ID]: lengthHooks,
+				[PG_NUMERIC_CODEC_ID]: numericHooks,
+				[PG_BIT_CODEC_ID]: lengthHooks,
+				[PG_VARBIT_CODEC_ID]: lengthHooks,
+				[PG_TIMESTAMP_CODEC_ID]: precisionHooks,
+				[PG_TIMESTAMPTZ_CODEC_ID]: precisionHooks,
+				[PG_TIME_CODEC_ID]: precisionHooks,
+				[PG_TIMETZ_CODEC_ID]: precisionHooks,
+				[PG_INTERVAL_CODEC_ID]: precisionHooks,
+				[PG_JSON_CODEC_ID]: identityHooks,
+				[PG_JSONB_CODEC_ID]: identityHooks,
+				[PG_BYTEA_CODEC_ID]: identityHooks
+			}
+		},
+		storage: [
+			{
+				typeId: PG_TEXT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "text"
+			},
+			{
+				typeId: SQL_TEXT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "text"
+			},
+			{
+				typeId: SQL_CHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character"
+			},
+			{
+				typeId: SQL_VARCHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character varying"
+			},
+			{
+				typeId: SQL_INT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: SQL_FLOAT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: SQL_TIMESTAMP_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamp"
+			},
+			{
+				typeId: PG_CHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character"
+			},
+			{
+				typeId: PG_VARCHAR_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "character varying"
+			},
+			{
+				typeId: PG_INT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: PG_FLOAT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_INT4_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int4"
+			},
+			{
+				typeId: PG_INT2_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int2"
+			},
+			{
+				typeId: PG_INT8_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "int8"
+			},
+			{
+				typeId: PG_FLOAT4_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float4"
+			},
+			{
+				typeId: PG_FLOAT8_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "float8"
+			},
+			{
+				typeId: PG_NUMERIC_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "numeric"
+			},
+			{
+				typeId: PG_TIMESTAMP_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamp"
+			},
+			{
+				typeId: PG_TIMESTAMPTZ_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timestamptz"
+			},
+			{
+				typeId: PG_TIME_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "time"
+			},
+			{
+				typeId: PG_TIMETZ_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "timetz"
+			},
+			{
+				typeId: PG_BOOL_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bool"
+			},
+			{
+				typeId: PG_BIT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bit"
+			},
+			{
+				typeId: PG_VARBIT_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bit varying"
+			},
+			{
+				typeId: PG_INTERVAL_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "interval"
+			},
+			{
+				typeId: PG_JSON_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "json"
+			},
+			{
+				typeId: PG_JSONB_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "jsonb"
+			},
+			{
+				typeId: PG_BYTEA_CODEC_ID,
+				familyId: "sql",
+				targetId: "postgres",
+				nativeType: "bytea"
+			}
+		],
+		queryOperationTypes: { import: {
+			package: "@prisma-next/adapter-postgres/operation-types",
+			named: "QueryOperationTypes",
+			alias: "PgAdapterQueryOps"
+		} }
+	}
+};
+//#endregion
+export { postgresQueryOperations as n, postgresAdapterDescriptorMeta as t };
+
+//# sourceMappingURL=descriptor-meta-ZIv9PU-5.mjs.map

package/dist/descriptor-meta-ZIv9PU-5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptor-meta-ZIv9PU-5.mjs","names":[],"sources":["../src/core/descriptor-meta.ts"],"sourcesContent":["import type { CodecControlHooks, ExpandNativeTypeInput } from '@prisma-next/family-sql/control';\nimport {\n  buildOperation,\n  type CodecExpression,\n  type Expression,\n  type TraitExpression,\n  toExpr,\n} from '@prisma-next/sql-relational-core/expression';\nimport {\n  PG_BIT_CODEC_ID,\n  PG_BOOL_CODEC_ID,\n  PG_BYTEA_CODEC_ID,\n  PG_CHAR_CODEC_ID,\n  PG_FLOAT_CODEC_ID,\n  PG_FLOAT4_CODEC_ID,\n  PG_FLOAT8_CODEC_ID,\n  PG_INT_CODEC_ID,\n  PG_INT2_CODEC_ID,\n  PG_INT4_CODEC_ID,\n  PG_INT8_CODEC_ID,\n  PG_INTERVAL_CODEC_ID,\n  PG_JSON_CODEC_ID,\n  PG_JSONB_CODEC_ID,\n  PG_NUMERIC_CODEC_ID,\n  PG_TEXT_CODEC_ID,\n  PG_TIME_CODEC_ID,\n  PG_TIMESTAMP_CODEC_ID,\n  PG_TIMESTAMPTZ_CODEC_ID,\n  PG_TIMETZ_CODEC_ID,\n  PG_VARBIT_CODEC_ID,\n  PG_VARCHAR_CODEC_ID,\n  SQL_CHAR_CODEC_ID,\n  SQL_FLOAT_CODEC_ID,\n  SQL_INT_CODEC_ID,\n  SQL_TEXT_CODEC_ID,\n  SQL_TIMESTAMP_CODEC_ID,\n  SQL_VARCHAR_CODEC_ID,\n} from '@prisma-next/target-postgres/codec-ids';\nimport { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';\nimport type { QueryOperationTypes } from '../types/operation-types';\n\n// ============================================================================ Helper functions for reducing boilerplate ============================================================================\n\n/** Creates a type import spec for codec types */\nconst codecTypeImport = (named: string) =>\n  ({\n    package: '@prisma-next/target-postgres/codec-types',\n    named,\n    alias: named,\n  }) as const;\n\nfunction isPositiveInteger(value: unknown): value is number {\n  return (\n    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value > 0\n  );\n}\n\nfunction isNonNegativeInteger(value: unknown): value is number {\n  return (\n    typeof value === 'number' && Number.isFinite(value) && Number.isInteger(value) && value >= 0\n  );\n}\n\nfunction expandLength({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  if (!typeParams || !('length' in typeParams)) {\n    return nativeType;\n  }\n  const length = typeParams['length'];\n  if (!isPositiveInteger(length)) {\n    throw new Error(\n      `Invalid \"length\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(length)}`,\n    );\n  }\n  return `${nativeType}(${length})`;\n}\n\nfunction expandPrecision({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  if (!typeParams || !('precision' in typeParams)) {\n    return nativeType;\n  }\n  const precision = typeParams['precision'];\n  if (!isPositiveInteger(precision)) {\n    throw new Error(\n      `Invalid \"precision\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(precision)}`,\n    );\n  }\n  return `${nativeType}(${precision})`;\n}\n\nfunction expandNumeric({ nativeType, typeParams }: ExpandNativeTypeInput): string {\n  const hasPrecision = typeParams && 'precision' in typeParams;\n  const hasScale = typeParams && 'scale' in typeParams;\n\n  if (!hasPrecision && !hasScale) {\n    return nativeType;\n  }\n\n  if (!hasPrecision && hasScale) {\n    throw new Error(\n      `Invalid type parameters for \"${nativeType}\": \"scale\" requires \"precision\" to be specified`,\n    );\n  }\n\n  if (hasPrecision) {\n    const precision = typeParams['precision'];\n    if (!isPositiveInteger(precision)) {\n      throw new Error(\n        `Invalid \"precision\" type parameter for \"${nativeType}\": expected a positive integer, got ${JSON.stringify(precision)}`,\n      );\n    }\n    if (hasScale) {\n      const scale = typeParams['scale'];\n      if (!isNonNegativeInteger(scale)) {\n        throw new Error(\n          `Invalid \"scale\" type parameter for \"${nativeType}\": expected a non-negative integer, got ${JSON.stringify(scale)}`,\n        );\n      }\n      return `${nativeType}(${precision},${scale})`;\n    }\n    return `${nativeType}(${precision})`;\n  }\n\n  return nativeType;\n}\n\nconst lengthHooks: CodecControlHooks = { expandNativeType: expandLength };\nconst precisionHooks: CodecControlHooks = { expandNativeType: expandPrecision };\nconst numericHooks: CodecControlHooks = { expandNativeType: expandNumeric };\nconst identityHooks: CodecControlHooks = { expandNativeType: ({ nativeType }) => nativeType };\n\n// ============================================================================ Descriptor metadata ============================================================================\n\ntype CodecTypesBase = Record<string, { readonly input: unknown; readonly output: unknown }>;\n\nexport function postgresQueryOperations<CT extends CodecTypesBase>(): QueryOperationTypes<CT> {\n  return {\n    ilike: {\n      self: { traits: ['textual'] },\n      impl: (\n        self: TraitExpression<readonly ['textual'], false, CT>,\n        pattern: CodecExpression<'pg/text@1', false, CT>,\n      ): Expression<{ codecId: 'pg/bool@1'; nullable: false }> => {\n        return buildOperation({\n          method: 'ilike',\n          args: [toExpr(self), toExpr(pattern, { codecId: PG_TEXT_CODEC_ID })],\n          returns: { codecId: PG_BOOL_CODEC_ID, nullable: false },\n          lowering: { targetFamily: 'sql', strategy: 'infix', template: '{{self}} ILIKE {{arg0}}' },\n        });\n      },\n    },\n  };\n}\n\nexport const postgresAdapterDescriptorMeta = {\n  kind: 'adapter',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {\n    postgres: {\n      orderBy: true,\n      limit: true,\n      lateral: true,\n      jsonAgg: true,\n      returning: true,\n    },\n    sql: {\n      enums: true,\n      returning: true,\n      defaultInInsert: true,\n    },\n  },\n  types: {\n    codecTypes: {\n      codecDescriptors: Array.from(postgresCodecRegistry.values()),\n      import: {\n        package: '@prisma-next/target-postgres/codec-types',\n        named: 'CodecTypes',\n        alias: 'PgTypes',\n      },\n      typeImports: [\n        {\n          package: '@prisma-next/target-postgres/codec-types',\n          named: 'JsonValue',\n          alias: 'JsonValue',\n        },\n        codecTypeImport('Char'),\n        codecTypeImport('Varchar'),\n        codecTypeImport('Numeric'),\n        codecTypeImport('Bit'),\n        codecTypeImport('VarBit'),\n        codecTypeImport('Timestamp'),\n        codecTypeImport('Timestamptz'),\n        codecTypeImport('Time'),\n        codecTypeImport('Timetz'),\n        codecTypeImport('Interval'),\n      ],\n      controlPlaneHooks: {\n        [SQL_CHAR_CODEC_ID]: lengthHooks,\n        [SQL_VARCHAR_CODEC_ID]: lengthHooks,\n        [SQL_TIMESTAMP_CODEC_ID]: precisionHooks,\n        [PG_CHAR_CODEC_ID]: lengthHooks,\n        [PG_VARCHAR_CODEC_ID]: lengthHooks,\n        [PG_NUMERIC_CODEC_ID]: numericHooks,\n        [PG_BIT_CODEC_ID]: lengthHooks,\n        [PG_VARBIT_CODEC_ID]: lengthHooks,\n        [PG_TIMESTAMP_CODEC_ID]: precisionHooks,\n        [PG_TIMESTAMPTZ_CODEC_ID]: precisionHooks,\n        [PG_TIME_CODEC_ID]: precisionHooks,\n        [PG_TIMETZ_CODEC_ID]: precisionHooks,\n        [PG_INTERVAL_CODEC_ID]: precisionHooks,\n        [PG_JSON_CODEC_ID]: identityHooks,\n        [PG_JSONB_CODEC_ID]: identityHooks,\n        [PG_BYTEA_CODEC_ID]: identityHooks,\n      },\n    },\n    storage: [\n      { typeId: PG_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: SQL_TEXT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'text' },\n      { typeId: SQL_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },\n      {\n        typeId: SQL_VARCHAR_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'character varying',\n      },\n      { typeId: SQL_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: SQL_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      {\n        typeId: SQL_TIMESTAMP_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamp',\n      },\n      { typeId: PG_CHAR_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'character' },\n      {\n        typeId: PG_VARCHAR_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'character varying',\n      },\n      { typeId: PG_INT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: PG_FLOAT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: PG_INT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int4' },\n      { typeId: PG_INT2_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int2' },\n      { typeId: PG_INT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'int8' },\n      { typeId: PG_FLOAT4_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float4' },\n      { typeId: PG_FLOAT8_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'float8' },\n      { typeId: PG_NUMERIC_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'numeric' },\n      {\n        typeId: PG_TIMESTAMP_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamp',\n      },\n      {\n        typeId: PG_TIMESTAMPTZ_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'timestamptz',\n      },\n      { typeId: PG_TIME_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'time' },\n      { typeId: PG_TIMETZ_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'timetz' },\n      { typeId: PG_BOOL_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bool' },\n      { typeId: PG_BIT_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bit' },\n      {\n        typeId: PG_VARBIT_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'bit varying',\n      },\n      {\n        typeId: PG_INTERVAL_CODEC_ID,\n        familyId: 'sql',\n        targetId: 'postgres',\n        nativeType: 'interval',\n      },\n      { typeId: PG_JSON_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'json' },\n      { typeId: PG_JSONB_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'jsonb' },\n      { typeId: PG_BYTEA_CODEC_ID, familyId: 'sql', targetId: 'postgres', nativeType: 'bytea' },\n    ],\n    queryOperationTypes: {\n      import: {\n        package: '@prisma-next/adapter-postgres/operation-types',\n        named: 'QueryOperationTypes',\n        alias: 'PgAdapterQueryOps',\n      },\n    },\n  },\n} as const;\n"],"mappings":"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"}

package/dist/runtime.mjs

@@ -1,5 +1,5 @@
 import { t as createPostgresAdapter } from "./adapter-BFQQweRI.mjs";
-import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-DvzAuIyE.mjs";
+import { n as postgresQueryOperations, t as postgresAdapterDescriptorMeta } from "./descriptor-meta-ZIv9PU-5.mjs";
 import { extractCodecLookup } from "@prisma-next/framework-components/control";
 import { postgresCodecRegistry } from "@prisma-next/target-postgres/codecs";
 import { builtinGeneratorIds } from "@prisma-next/ids";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/adapter-postgres",
-  "version": "0.8.0",
+  "version": "0.9.0-dev.2",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -9,30 +9,30 @@
     "src"
   ],
   "dependencies": {
-    "@prisma-next/contract": "0.8.0",
-    "@prisma-next/contract-authoring": "0.8.0",
-    "@prisma-next/family-sql": "0.8.0",
-    "@prisma-next/framework-components": "0.8.0",
-    "@prisma-next/ids": "0.8.0",
-    "@prisma-next/sql-contract": "0.8.0",
-    "@prisma-next/sql-contract-psl": "0.8.0",
-    "@prisma-next/sql-contract-ts": "0.8.0",
-    "@prisma-next/sql-operations": "0.8.0",
-    "@prisma-next/sql-relational-core": "0.8.0",
-    "@prisma-next/sql-runtime": "0.8.0",
-    "@prisma-next/sql-schema-ir": "0.8.0",
-    "@prisma-next/target-postgres": "0.8.0",
-    "@prisma-next/utils": "0.8.0",
+    "@prisma-next/contract": "0.9.0-dev.2",
+    "@prisma-next/contract-authoring": "0.9.0-dev.2",
+    "@prisma-next/family-sql": "0.9.0-dev.2",
+    "@prisma-next/framework-components": "0.9.0-dev.2",
+    "@prisma-next/ids": "0.9.0-dev.2",
+    "@prisma-next/sql-contract": "0.9.0-dev.2",
+    "@prisma-next/sql-contract-psl": "0.9.0-dev.2",
+    "@prisma-next/sql-contract-ts": "0.9.0-dev.2",
+    "@prisma-next/sql-operations": "0.9.0-dev.2",
+    "@prisma-next/sql-relational-core": "0.9.0-dev.2",
+    "@prisma-next/sql-runtime": "0.9.0-dev.2",
+    "@prisma-next/sql-schema-ir": "0.9.0-dev.2",
+    "@prisma-next/target-postgres": "0.9.0-dev.2",
+    "@prisma-next/utils": "0.9.0-dev.2",
     "arktype": "^2.1.29"
   },
   "devDependencies": {
-    "@prisma-next/cli": "0.8.0",
-    "@prisma-next/driver-postgres": "0.8.0",
-    "@prisma-next/errors": "0.8.0",
-    "@prisma-next/migration-tools": "0.8.0",
-    "@prisma-next/test-utils": "0.8.0",
-    "@prisma-next/tsconfig": "0.8.0",
-    "@prisma-next/tsdown": "0.8.0",
+    "@prisma-next/cli": "0.9.0-dev.2",
+    "@prisma-next/driver-postgres": "0.9.0-dev.2",
+    "@prisma-next/errors": "0.9.0-dev.2",
+    "@prisma-next/migration-tools": "0.9.0-dev.2",
+    "@prisma-next/test-utils": "0.9.0-dev.2",
+    "@prisma-next/tsconfig": "0.9.0-dev.2",
+    "@prisma-next/tsdown": "0.9.0-dev.2",
     "pathe": "^2.0.3",
     "tsdown": "0.22.0",
     "typescript": "5.9.3",

package/src/core/control-adapter.ts

@@ -3,6 +3,7 @@ import type { SqlControlAdapter } from '@prisma-next/family-sql/control-adapter'
 import { parseContractMarkerRow } from '@prisma-next/family-sql/verify';
 import type { CodecLookup } from '@prisma-next/framework-components/codec';
 import type { ControlDriverInstance } from '@prisma-next/framework-components/control';
+import type { PostgresEnumStorageEntry } from '@prisma-next/sql-contract/types';
 import type {
   AnyQueryAst,
   LoweredStatement,
@@ -19,10 +20,11 @@ import type {
   SqlUniqueIR,
 } from '@prisma-next/sql-schema-ir/types';
 import { parsePostgresDefault } from '@prisma-next/target-postgres/default-normalizer';
+import { readExistingEnumValues } from '@prisma-next/target-postgres/enum-planning';
 import { normalizeSchemaNativeType } from '@prisma-next/target-postgres/native-type-normalizer';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { createPostgresBuiltinCodecLookup } from './codec-lookup';
-import { pgEnumControlHooks } from './enum-control-hooks';
+import { introspectPostgresEnumTypes } from './enum-control-hooks';
 import { renderLoweredSql } from './sql-renderer';
 import type { PostgresContract } from './types';
 
@@ -60,6 +62,17 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
    */
   readonly normalizeNativeType = normalizeSchemaNativeType;
 
+  /**
+   * Bridges native `PostgresEnumStorageEntry` IR walks against the Postgres
+   * introspection shape (`schema.annotations.pg.storageTypes`). Lets
+   * the family-level schema verifier walk enum types without reaching
+   * into target-specific annotation layouts itself.
+   */
+  readonly resolveExistingEnumValues = (
+    schema: SqlSchemaIR,
+    enumType: PostgresEnumStorageEntry,
+  ): readonly string[] | null => readExistingEnumValues(schema, enumType.nativeType);
+
   /**
    * Lower a SQL query AST into a Postgres-flavored `{ sql, params }` payload.
    *
@@ -573,8 +586,7 @@ export class PostgresControlAdapter implements SqlControlAdapter<'postgres'> {
       };
     }
 
-    const storageTypes =
-      (await pgEnumControlHooks.introspectTypes?.({ driver, schemaName: schema })) ?? {};
+    const storageTypes = await introspectPostgresEnumTypes({ driver, schemaName: schema });
 
     const annotations = {
       pg: {

package/src/core/descriptor-meta.ts

@@ -11,7 +11,6 @@ import {
   PG_BOOL_CODEC_ID,
   PG_BYTEA_CODEC_ID,
   PG_CHAR_CODEC_ID,
-  PG_ENUM_CODEC_ID,
   PG_FLOAT_CODEC_ID,
   PG_FLOAT4_CODEC_ID,
   PG_FLOAT8_CODEC_ID,
@@ -39,7 +38,6 @@ import {
 } from '@prisma-next/target-postgres/codec-ids';
 import { postgresCodecRegistry } from '@prisma-next/target-postgres/codecs';
 import type { QueryOperationTypes } from '../types/operation-types';
-import { pgEnumControlHooks } from './enum-control-hooks';
 
 // ============================================================================ Helper functions for reducing boilerplate ============================================================================
 
@@ -212,7 +210,6 @@ export const postgresAdapterDescriptorMeta = {
         [PG_TIME_CODEC_ID]: precisionHooks,
         [PG_TIMETZ_CODEC_ID]: precisionHooks,
         [PG_INTERVAL_CODEC_ID]: precisionHooks,
-        [PG_ENUM_CODEC_ID]: pgEnumControlHooks,
         [PG_JSON_CODEC_ID]: identityHooks,
         [PG_JSONB_CODEC_ID]: identityHooks,
         [PG_BYTEA_CODEC_ID]: identityHooks,