@prisma-next/target-postgres 0.14.0-dev.5 → 0.14.0-dev.50

package/dist/authoring-DzHOdWTl.mjs

@@ -0,0 +1,364 @@
+import { a as PG_ENUM_CODEC_ID } from "./codec-ids-C_-Hj6bL.mjs";
+import { t as PostgresNativeEnum } from "./postgres-native-enum-xdiqmBf_.mjs";
+import { d as PostgresRoleSchema, f as PostgresRole, l as PostgresNativeEnumSchema, p as PostgresRlsPolicy, u as PostgresRlsPolicySchema } from "./postgres-schema-CajYAwny.mjs";
+import { n as normalizePredicate, t as computeContentHash } from "./canonicalize-Bn3BM1Cn.mjs";
+import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
+//#region src/core/authoring.ts
+/**
+* `pg.enum(<ref>)` registers as an ordinary type constructor whose sole
+* positional argument names a `native_enum` entity instead of carrying a
+* literal value. The interpreter resolves the ref to the `native_enum`
+* entity generically (driven by `entityRefArg`); the `pg/enum@1` codec
+* descriptor's `columnFromEntity` hook (see `codecs.ts`) converts that
+* entity into the column's `typeParams` and native type.
+*/
+const postgresAuthoringTypes = { pg: { enum: {
+	kind: "typeConstructor",
+	entityRefArg: {
+		index: 0,
+		entityKind: "native_enum"
+	},
+	output: { codecId: PG_ENUM_CODEC_ID }
+} } };
+function readRefParam(block, key) {
+	const param = block.parameters[key];
+	return param?.kind === "ref" ? param.identifier : void 0;
+}
+function readValueParam(block, key) {
+	const param = block.parameters[key];
+	return param?.kind === "value" ? param.raw : void 0;
+}
+function readListRefParams(block, key) {
+	const param = block.parameters[key];
+	if (param?.kind !== "list") return [];
+	return param.items.flatMap((item) => item.kind === "ref" ? [item.identifier] : []);
+}
+function unwrapQuotedString(raw) {
+	if (raw.startsWith("\"") && raw.endsWith("\"") && raw.length >= 2) return raw.slice(1, -1).replace(/\\"/g, "\"");
+	return raw;
+}
+function lowerRlsPolicyFromBlock(block, _ctx) {
+	const prefix = block.name;
+	const targetModelName = readRefParam(block, "target") ?? "";
+	const tableName = targetModelName.charAt(0).toLowerCase() + targetModelName.slice(1);
+	const roles = [...readListRefParams(block, "roles")].sort();
+	const using = unwrapQuotedString(readValueParam(block, "using") ?? "");
+	return new PostgresRlsPolicy({
+		name: `${prefix}_${computeContentHash({
+			using: normalizePredicate(using),
+			roles,
+			operation: "select",
+			permissive: true
+		})}`,
+		prefix,
+		tableName,
+		namespaceId: block.namespaceId,
+		operation: "select",
+		roles,
+		using,
+		permissive: true
+	});
+}
+/**
+* Lowers a `native_enum { memberName = "value" … @@map("type_name") }` block
+* into a {@link PostgresNativeEnum}. Members must be authored as explicit
+* `key = "value"` pairs — a bare (value-less) member is a diagnostic, not
+* accepted (authoring-design.md §2.1). The parsed `memberName` is only used
+* to duplicate-check and report diagnostics; the lowered entity carries just
+* the member values (a native enum is value-only — the member "name" isn't
+* a separate authoring concept from the value). `typeName` comes from
+* `@@map` or defaults to the block name verbatim.
+*/
+function lowerNativeEnumFromBlock(block, ctx) {
+	const sourceId = ctx.sourceId ?? "unknown";
+	const diagnostics = ctx.diagnostics;
+	const mapAttr = block.blockAttributes.find((a) => a.name === "map");
+	let typeName = block.name;
+	if (mapAttr) {
+		const rawArg = mapAttr.args[0]?.value;
+		const mapped = rawArg !== void 0 ? unwrapQuotedString(rawArg) : void 0;
+		if (mapped === void 0) {
+			diagnostics?.push({
+				code: "PSL_NATIVE_ENUM_INVALID_MAP",
+				message: `native_enum "${block.name}" @@map attribute must have a quoted type-name argument`,
+				sourceId,
+				span: mapAttr.span
+			});
+			return;
+		}
+		typeName = mapped;
+	}
+	let memberError = false;
+	const seenValues = /* @__PURE__ */ new Set();
+	const members = [];
+	for (const [memberName, paramValue] of Object.entries(block.parameters)) {
+		if (paramValue.kind === "bare") {
+			diagnostics?.push({
+				code: "PSL_NATIVE_ENUM_BARE_MEMBER",
+				message: `native_enum "${block.name}" member "${memberName}" has no value; members must be authored as "${memberName} = \\"value\\""`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		if (paramValue.kind !== "value") continue;
+		let jsonValue;
+		try {
+			jsonValue = JSON.parse(paramValue.raw);
+		} catch {
+			diagnostics?.push({
+				code: "PSL_EXTENSION_INVALID_VALUE",
+				message: `native_enum "${block.name}" member "${memberName}" value "${paramValue.raw}" is not valid JSON`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		if (typeof jsonValue !== "string") {
+			diagnostics?.push({
+				code: "PSL_EXTENSION_INVALID_VALUE",
+				message: `native_enum "${block.name}" member "${memberName}" value must be a string`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		if (seenValues.has(jsonValue)) {
+			diagnostics?.push({
+				code: "PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE",
+				message: `native_enum "${block.name}": duplicate member value "${jsonValue}"`,
+				sourceId,
+				span: paramValue.span
+			});
+			memberError = true;
+			continue;
+		}
+		seenValues.add(jsonValue);
+		members.push(jsonValue);
+	}
+	if (memberError) return void 0;
+	if (members.length === 0) {
+		diagnostics?.push({
+			code: "PSL_NATIVE_ENUM_MISSING_MEMBERS",
+			message: `native_enum "${block.name}" must have at least one member`,
+			sourceId,
+			span: block.span
+		});
+		return;
+	}
+	return new PostgresNativeEnum({
+		typeName,
+		members
+	});
+}
+const postgresAuthoringEntityTypes = {
+	role: {
+		kind: "entity",
+		discriminator: "role",
+		validatorSchema: PostgresRoleSchema,
+		output: { factory: (input) => new PostgresRole(input) }
+	},
+	policy: {
+		kind: "entity",
+		discriminator: "policy",
+		validatorSchema: PostgresRlsPolicySchema,
+		output: { factory: lowerRlsPolicyFromBlock }
+	},
+	native_enum: {
+		kind: "entity",
+		discriminator: "native_enum",
+		validatorSchema: PostgresNativeEnumSchema,
+		output: {
+			factory: lowerNativeEnumFromBlock,
+			deriveValueSet: (entity) => ({
+				kind: "valueSet",
+				values: [...entity.members]
+			})
+		}
+	}
+};
+/**
+* Field presets contributed by the Postgres target pack.
+*
+* These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
+* (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
+* via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
+* surface (e.g. `Int`) lowers to byte-identical contracts.
+*
+* The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the
+* native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target
+* portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from
+* the family pack instead.
+*/
+/**
+* PSL block descriptor for `policy_select`.
+*
+* The parser learns the block shape from this descriptor; lowering from
+* `PslExtensionBlock` to `PostgresRlsPolicy` is wired in the PSL
+* interpreter (a later dispatch). The `discriminator` matches
+* `PostgresRlsPolicy.kind` so the parsed block node carries the same
+* discriminant as the IR class it will lower to.
+*
+* The `roles` list uses `scope:'cross-space'` because same-namespace
+* role ref resolution requires PSL namespace entries keyed by `refKind`
+* (i.e. `'role'`), which in turn requires the role block discriminator to
+* equal `'role'`. Aligning discriminator with refKind is tracked for
+* slice 4 (cross-space roles). Until then cross-space passes validation
+* unconditionally and the authored role names flow through unchanged.
+*/
+const postgresAuthoringPslBlockDescriptors = {
+	policy_select: {
+		kind: "pslBlock",
+		keyword: "policy_select",
+		discriminator: "policy",
+		name: { required: true },
+		parameters: {
+			target: {
+				kind: "ref",
+				refKind: "model",
+				scope: "same-namespace",
+				required: true
+			},
+			roles: {
+				kind: "list",
+				of: {
+					kind: "ref",
+					refKind: "role",
+					scope: "cross-space"
+				}
+			},
+			using: {
+				kind: "value",
+				codecId: "pg/text@1",
+				required: true
+			}
+		}
+	},
+	/**
+	* PSL block descriptor for `native_enum`.
+	*
+	* Reuses the existing variadic-block mechanism (the same shape the SQL
+	* family's `enum` block ships): the body is an open `memberName = "value"`
+	* list. `variadicParameters: true` opens the block to arbitrary keys
+	* beyond the declared (empty) `parameters` set — the lowering factory
+	* (`lowerNativeEnumFromBlock`) turns the variadic entries into ordered
+	* members and rejects a bare (value-less) member.
+	*/
+	native_enum: {
+		kind: "pslBlock",
+		keyword: "native_enum",
+		discriminator: "native_enum",
+		name: { required: true },
+		parameters: {},
+		variadicParameters: true
+	}
+};
+const postgresAuthoringFieldPresets = {
+	text: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/text@1",
+			nativeType: "text"
+		}
+	},
+	int: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int4@1",
+			nativeType: "int4"
+		}
+	},
+	bigint: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/int8@1",
+			nativeType: "int8"
+		}
+	},
+	float: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/float8@1",
+			nativeType: "float8"
+		}
+	},
+	decimal: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/numeric@1",
+			nativeType: "numeric"
+		}
+	},
+	boolean: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bool@1",
+			nativeType: "bool"
+		}
+	},
+	json: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/jsonb@1",
+			nativeType: "jsonb"
+		}
+	},
+	bytes: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/bytea@1",
+			nativeType: "bytea"
+		}
+	},
+	dateTime: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/timestamptz@1",
+			nativeType: "timestamptz"
+		}
+	},
+	temporal: /* @__PURE__ */ temporalAuthoringPresets({
+		codecId: "pg/timestamptz@1",
+		nativeType: "timestamptz"
+	}),
+	uuidNative: {
+		kind: "fieldPreset",
+		output: {
+			codecId: "pg/uuid@1",
+			nativeType: "uuid"
+		}
+	},
+	id: {
+		uuidv4Native: {
+			kind: "fieldPreset",
+			output: {
+				codecId: "pg/uuid@1",
+				nativeType: "uuid",
+				executionDefaults: { onCreate: {
+					kind: "generator",
+					id: "uuidv4"
+				} },
+				id: true
+			}
+		},
+		uuidv7Native: {
+			kind: "fieldPreset",
+			output: {
+				codecId: "pg/uuid@1",
+				nativeType: "uuid",
+				executionDefaults: { onCreate: {
+					kind: "generator",
+					id: "uuidv7"
+				} },
+				id: true
+			}
+		}
+	}
+};
+//#endregion
+export { postgresAuthoringTypes as i, postgresAuthoringFieldPresets as n, postgresAuthoringPslBlockDescriptors as r, postgresAuthoringEntityTypes as t };
+
+//# sourceMappingURL=authoring-DzHOdWTl.mjs.map

package/dist/authoring-DzHOdWTl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-DzHOdWTl.mjs","names":[],"sources":["../src/core/authoring.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityContext,\n  AuthoringEntityTypeFactoryOutput,\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringPslBlockDescriptorNamespace,\n  AuthoringTypeNamespace,\n  PslExtensionBlock,\n} from '@prisma-next/framework-components/authoring';\nimport type { SqlValueSetDerivingEntityTypeOutput } from '@prisma-next/sql-contract/value-set-derivation-hook';\nimport { PG_ENUM_CODEC_ID } from './codec-ids';\nimport { PostgresNativeEnum } from './postgres-native-enum';\nimport { PostgresRlsPolicy } from './postgres-rls-policy';\nimport { PostgresRole, type PostgresRoleInput } from './postgres-role';\nimport {\n  PostgresNativeEnumSchema,\n  PostgresRlsPolicySchema,\n  PostgresRoleSchema,\n} from './postgres-validators';\nimport { computeContentHash, normalizePredicate } from './rls/canonicalize';\n\n/**\n * `pg.enum(<ref>)` registers as an ordinary type constructor whose sole\n * positional argument names a `native_enum` entity instead of carrying a\n * literal value. The interpreter resolves the ref to the `native_enum`\n * entity generically (driven by `entityRefArg`); the `pg/enum@1` codec\n * descriptor's `columnFromEntity` hook (see `codecs.ts`) converts that\n * entity into the column's `typeParams` and native type.\n */\nexport const postgresAuthoringTypes = {\n  pg: {\n    enum: {\n      kind: 'typeConstructor',\n      entityRefArg: { index: 0, entityKind: 'native_enum' },\n      output: {\n        codecId: PG_ENUM_CODEC_ID,\n      },\n    },\n  },\n} as const satisfies AuthoringTypeNamespace;\n\nexport interface RlsPolicyExtensionBlock extends PslExtensionBlock {\n  readonly namespaceId: string;\n}\n\nfunction readRefParam(block: PslExtensionBlock, key: string): string | undefined {\n  const param = block.parameters[key];\n  return param?.kind === 'ref' ? param.identifier : undefined;\n}\n\nfunction readValueParam(block: PslExtensionBlock, key: string): string | undefined {\n  const param = block.parameters[key];\n  return param?.kind === 'value' ? param.raw : undefined;\n}\n\nfunction readListRefParams(block: PslExtensionBlock, key: string): string[] {\n  const param = block.parameters[key];\n  if (param?.kind !== 'list') return [];\n  return param.items.flatMap((item) => (item.kind === 'ref' ? [item.identifier] : []));\n}\n\nfunction unwrapQuotedString(raw: string): string {\n  if (raw.startsWith('\"') && raw.endsWith('\"') && raw.length >= 2) {\n    return raw.slice(1, -1).replace(/\\\\\"/g, '\"');\n  }\n  return raw;\n}\n\nfunction lowerRlsPolicyFromBlock(\n  block: RlsPolicyExtensionBlock,\n  _ctx: AuthoringEntityContext,\n): PostgresRlsPolicy {\n  const prefix = block.name;\n  const targetModelName = readRefParam(block, 'target') ?? '';\n  const tableName = targetModelName.charAt(0).toLowerCase() + targetModelName.slice(1);\n  const roles = [...readListRefParams(block, 'roles')].sort();\n  const using = unwrapQuotedString(readValueParam(block, 'using') ?? '');\n\n  const wireHash = computeContentHash({\n    using: normalizePredicate(using),\n    roles,\n    operation: 'select',\n    permissive: true,\n  });\n  const wireName = `${prefix}_${wireHash}`;\n\n  return new PostgresRlsPolicy({\n    name: wireName,\n    prefix,\n    tableName,\n    namespaceId: block.namespaceId,\n    operation: 'select',\n    roles,\n    using,\n    permissive: true,\n  });\n}\n\n/**\n * Lowers a `native_enum { memberName = \"value\" … @@map(\"type_name\") }` block\n * into a {@link PostgresNativeEnum}. Members must be authored as explicit\n * `key = \"value\"` pairs — a bare (value-less) member is a diagnostic, not\n * accepted (authoring-design.md §2.1). The parsed `memberName` is only used\n * to duplicate-check and report diagnostics; the lowered entity carries just\n * the member values (a native enum is value-only — the member \"name\" isn't\n * a separate authoring concept from the value). `typeName` comes from\n * `@@map` or defaults to the block name verbatim.\n */\nfunction lowerNativeEnumFromBlock(\n  block: PslExtensionBlock,\n  ctx: AuthoringEntityContext,\n): PostgresNativeEnum | undefined {\n  const sourceId = ctx.sourceId ?? 'unknown';\n  const diagnostics = ctx.diagnostics;\n\n  const mapAttr = block.blockAttributes.find((a) => a.name === 'map');\n  let typeName = block.name;\n  if (mapAttr) {\n    const rawArg = mapAttr.args[0]?.value;\n    const mapped = rawArg !== undefined ? unwrapQuotedString(rawArg) : undefined;\n    if (mapped === undefined) {\n      diagnostics?.push({\n        code: 'PSL_NATIVE_ENUM_INVALID_MAP',\n        message: `native_enum \"${block.name}\" @@map attribute must have a quoted type-name argument`,\n        sourceId,\n        span: mapAttr.span,\n      });\n      return undefined;\n    }\n    typeName = mapped;\n  }\n\n  let memberError = false;\n  const seenValues = new Set<string>();\n  const members: string[] = [];\n  for (const [memberName, paramValue] of Object.entries(block.parameters)) {\n    if (paramValue.kind === 'bare') {\n      diagnostics?.push({\n        code: 'PSL_NATIVE_ENUM_BARE_MEMBER',\n        message: `native_enum \"${block.name}\" member \"${memberName}\" has no value; members must be authored as \"${memberName} = \\\\\"value\\\\\"\"`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    if (paramValue.kind !== 'value') continue;\n\n    let jsonValue: unknown;\n    try {\n      jsonValue = JSON.parse(paramValue.raw);\n    } catch {\n      diagnostics?.push({\n        code: 'PSL_EXTENSION_INVALID_VALUE',\n        message: `native_enum \"${block.name}\" member \"${memberName}\" value \"${paramValue.raw}\" is not valid JSON`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    if (typeof jsonValue !== 'string') {\n      diagnostics?.push({\n        code: 'PSL_EXTENSION_INVALID_VALUE',\n        message: `native_enum \"${block.name}\" member \"${memberName}\" value must be a string`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    if (seenValues.has(jsonValue)) {\n      diagnostics?.push({\n        code: 'PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE',\n        message: `native_enum \"${block.name}\": duplicate member value \"${jsonValue}\"`,\n        sourceId,\n        span: paramValue.span,\n      });\n      memberError = true;\n      continue;\n    }\n    seenValues.add(jsonValue);\n    members.push(jsonValue);\n  }\n\n  if (memberError) return undefined;\n\n  if (members.length === 0) {\n    diagnostics?.push({\n      code: 'PSL_NATIVE_ENUM_MISSING_MEMBERS',\n      message: `native_enum \"${block.name}\" must have at least one member`,\n      sourceId,\n      span: block.span,\n    });\n    return undefined;\n  }\n\n  // `control` stays unset — the effective grade is resolved at read time via `effectiveControlPolicy`, like `StorageTable`/`StorageColumn`.\n  return new PostgresNativeEnum({ typeName, members });\n}\n\n/**\n * `native_enum`'s entity-type factory output, checked separately from the assembled\n * `postgresAuthoringEntityTypes` map below: `deriveValueSet` is SQL-family surface\n * ({@link SqlValueSetDerivingEntityTypeOutput}), not part of the framework\n * `AuthoringEntityTypeFactoryOutput` shape, so folding it directly into the map's single\n * `satisfies AuthoringEntityTypeNamespace` check would trip an excess-property error. Checking it\n * here against the intersection of both shapes keeps it structurally valid against each without\n * widening the map's own check.\n */\nconst nativeEnumEntityTypeOutput = {\n  factory: lowerNativeEnumFromBlock,\n  deriveValueSet: (entity: PostgresNativeEnum) => ({\n    kind: 'valueSet' as const,\n    values: [...entity.members],\n  }),\n} satisfies AuthoringEntityTypeFactoryOutput<PslExtensionBlock, PostgresNativeEnum | undefined> &\n  SqlValueSetDerivingEntityTypeOutput;\n\nexport const postgresAuthoringEntityTypes = {\n  role: {\n    kind: 'entity',\n    discriminator: 'role',\n    validatorSchema: PostgresRoleSchema,\n    output: {\n      factory: (input: PostgresRoleInput): PostgresRole => new PostgresRole(input),\n    },\n  },\n  policy: {\n    kind: 'entity',\n    discriminator: 'policy',\n    validatorSchema: PostgresRlsPolicySchema,\n    output: {\n      factory: lowerRlsPolicyFromBlock,\n    },\n  },\n  native_enum: {\n    kind: 'entity',\n    discriminator: 'native_enum',\n    validatorSchema: PostgresNativeEnumSchema,\n    output: nativeEnumEntityTypeOutput,\n  },\n} as const satisfies AuthoringEntityTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n *\n * The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the\n * native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target\n * portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from\n * the family pack instead.\n */\n/**\n * PSL block descriptor for `policy_select`.\n *\n * The parser learns the block shape from this descriptor; lowering from\n * `PslExtensionBlock` to `PostgresRlsPolicy` is wired in the PSL\n * interpreter (a later dispatch). The `discriminator` matches\n * `PostgresRlsPolicy.kind` so the parsed block node carries the same\n * discriminant as the IR class it will lower to.\n *\n * The `roles` list uses `scope:'cross-space'` because same-namespace\n * role ref resolution requires PSL namespace entries keyed by `refKind`\n * (i.e. `'role'`), which in turn requires the role block discriminator to\n * equal `'role'`. Aligning discriminator with refKind is tracked for\n * slice 4 (cross-space roles). Until then cross-space passes validation\n * unconditionally and the authored role names flow through unchanged.\n */\nexport const postgresAuthoringPslBlockDescriptors = {\n  policy_select: {\n    kind: 'pslBlock',\n    keyword: 'policy_select',\n    discriminator: 'policy',\n    name: { required: true },\n    parameters: {\n      target: { kind: 'ref', refKind: 'model', scope: 'same-namespace', required: true },\n      roles: {\n        kind: 'list',\n        of: { kind: 'ref', refKind: 'role', scope: 'cross-space' },\n      },\n      using: { kind: 'value', codecId: 'pg/text@1', required: true },\n    },\n  },\n  /**\n   * PSL block descriptor for `native_enum`.\n   *\n   * Reuses the existing variadic-block mechanism (the same shape the SQL\n   * family's `enum` block ships): the body is an open `memberName = \"value\"`\n   * list. `variadicParameters: true` opens the block to arbitrary keys\n   * beyond the declared (empty) `parameters` set — the lowering factory\n   * (`lowerNativeEnumFromBlock`) turns the variadic entries into ordered\n   * members and rejects a bare (value-less) member.\n   */\n  native_enum: {\n    kind: 'pslBlock',\n    keyword: 'native_enum',\n    discriminator: 'native_enum',\n    name: { required: true },\n    parameters: {},\n    variadicParameters: true,\n  },\n} as const satisfies AuthoringPslBlockDescriptorNamespace;\n\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  temporal: /* @__PURE__ */ temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n  uuidNative: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/uuid@1',\n      nativeType: 'uuid',\n    },\n  },\n  id: {\n    uuidv4Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv4',\n          },\n        },\n        id: true,\n      },\n    },\n    uuidv7Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv7',\n          },\n        },\n        id: true,\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n"],"mappings":"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T,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAAU;EACR,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAA0B,yCAAyB;EACjD,SAAS;EACT,YAAY;CACd,CAAC;CACD,YAAY;EACV,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,IAAI;EACF,cAAc;GACZ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,mBAAmB,EACjB,UAAU;KACR,MAAM;KACN,IAAI;IACN,EACF;IACA,IAAI;GACN;EACF;EACA,cAAc;GACZ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,mBAAmB,EACjB,UAAU;KACR,MAAM;KACN,IAAI;IACN,EACF;IACA,IAAI;GACN;EACF;CACF;AACF"}

package/dist/canonicalize-Bn3BM1Cn.mjs

@@ -0,0 +1,46 @@
+import { createHash } from "node:crypto";
+//#region src/core/rls/canonicalize.ts
+/**
+* Stabilizes an authored predicate for hashing: trim, and collapse runs of
+* internal whitespace to a single space.
+*
+* This is deliberately minimal. The content hash is the equivalence relation
+* for a policy, and the wire name (prefix + hash) is the only thing ever
+* compared — we never recompute the hash from an introspected policy body, so
+* there is no need to match Postgres's reprinted form. Minimal normalization
+* also protects the no-collision property: aggressive rewriting (lowercasing,
+* paren-stripping, cast-alias folding) risks collapsing two distinct predicates
+* onto one hash. Out-of-band alteration of a hashed policy is unsupported.
+*
+* The normalizer is a stability commitment: any change re-suffixes all wire names.
+*/
+function normalizePredicate(sql) {
+	return sql.replace(/\s+/g, " ").trim();
+}
+/**
+* Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+* canonical content tuple for an RLS policy:
+*
+*   [normalize(using), normalize(withCheck), sortedRoles, operation, permissive]
+*
+* Schema and table are excluded (they are orthogonal to policy equivalence).
+* Uses `JSON.stringify` for a deterministic encoding.
+*/
+function computeContentHash(parts) {
+	const using = normalizePredicate(parts.using ?? "");
+	const withCheck = normalizePredicate(parts.withCheck ?? "");
+	const roles = [...new Set(parts.roles)].sort();
+	const permissive = parts.permissive ? "permissive" : "restrictive";
+	const tuple = JSON.stringify([
+		using,
+		withCheck,
+		roles,
+		parts.operation,
+		permissive
+	]);
+	return createHash("sha256").update(tuple).digest("hex").slice(0, 8);
+}
+//#endregion
+export { normalizePredicate as n, computeContentHash as t };
+
+//# sourceMappingURL=canonicalize-Bn3BM1Cn.mjs.map

package/dist/canonicalize-Bn3BM1Cn.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalize-Bn3BM1Cn.mjs","names":[],"sources":["../src/core/rls/canonicalize.ts"],"sourcesContent":["import { createHash } from 'node:crypto';\n\nexport type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';\n\nexport interface ContentHashParts {\n  readonly using?: string;\n  readonly withCheck?: string;\n  readonly roles: readonly string[];\n  readonly operation: RlsPolicyOperation;\n  readonly permissive: boolean;\n}\n\n/**\n * Stabilizes an authored predicate for hashing: trim, and collapse runs of\n * internal whitespace to a single space.\n *\n * This is deliberately minimal. The content hash is the equivalence relation\n * for a policy, and the wire name (prefix + hash) is the only thing ever\n * compared — we never recompute the hash from an introspected policy body, so\n * there is no need to match Postgres's reprinted form. Minimal normalization\n * also protects the no-collision property: aggressive rewriting (lowercasing,\n * paren-stripping, cast-alias folding) risks collapsing two distinct predicates\n * onto one hash. Out-of-band alteration of a hashed policy is unsupported.\n *\n * The normalizer is a stability commitment: any change re-suffixes all wire names.\n */\nexport function normalizePredicate(sql: string): string {\n  return sql.replace(/\\s+/g, ' ').trim();\n}\n\n/**\n * Returns the first 8 lowercase hex characters of the SHA-256 digest over the\n * canonical content tuple for an RLS policy:\n *\n *   [normalize(using), normalize(withCheck), sortedRoles, operation, permissive]\n *\n * Schema and table are excluded (they are orthogonal to policy equivalence).\n * Uses `JSON.stringify` for a deterministic encoding.\n */\nexport function computeContentHash(parts: ContentHashParts): string {\n  const using = normalizePredicate(parts.using ?? '');\n  const withCheck = normalizePredicate(parts.withCheck ?? '');\n  const roles = [...new Set(parts.roles)].sort();\n  const permissive = parts.permissive ? 'permissive' : 'restrictive';\n\n  const tuple = JSON.stringify([using, withCheck, roles, parts.operation, permissive]);\n  return createHash('sha256').update(tuple).digest('hex').slice(0, 8);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AA0BA,SAAgB,mBAAmB,KAAqB;CACtD,OAAO,IAAI,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;AACvC;;;;;;;;;;AAWA,SAAgB,mBAAmB,OAAiC;CAClE,MAAM,QAAQ,mBAAmB,MAAM,SAAS,EAAE;CAClD,MAAM,YAAY,mBAAmB,MAAM,aAAa,EAAE;CAC1D,MAAM,QAAQ,CAAC,GAAG,IAAI,IAAI,MAAM,KAAK,CAAC,CAAC,CAAC,KAAK;CAC7C,MAAM,aAAa,MAAM,aAAa,eAAe;CAErD,MAAM,QAAQ,KAAK,UAAU;EAAC;EAAO;EAAW;EAAO,MAAM;EAAW;CAAU,CAAC;CACnF,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC;AACpE"}

package/dist/canonicalize-CAbXtVtB.d.mts

@@ -0,0 +1,37 @@
+//#region src/core/rls/canonicalize.d.ts
+type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';
+interface ContentHashParts {
+  readonly using?: string;
+  readonly withCheck?: string;
+  readonly roles: readonly string[];
+  readonly operation: RlsPolicyOperation;
+  readonly permissive: boolean;
+}
+/**
+ * Stabilizes an authored predicate for hashing: trim, and collapse runs of
+ * internal whitespace to a single space.
+ *
+ * This is deliberately minimal. The content hash is the equivalence relation
+ * for a policy, and the wire name (prefix + hash) is the only thing ever
+ * compared — we never recompute the hash from an introspected policy body, so
+ * there is no need to match Postgres's reprinted form. Minimal normalization
+ * also protects the no-collision property: aggressive rewriting (lowercasing,
+ * paren-stripping, cast-alias folding) risks collapsing two distinct predicates
+ * onto one hash. Out-of-band alteration of a hashed policy is unsupported.
+ *
+ * The normalizer is a stability commitment: any change re-suffixes all wire names.
+ */
+declare function normalizePredicate(sql: string): string;
+/**
+ * Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+ * canonical content tuple for an RLS policy:
+ *
+ *   [normalize(using), normalize(withCheck), sortedRoles, operation, permissive]
+ *
+ * Schema and table are excluded (they are orthogonal to policy equivalence).
+ * Uses `JSON.stringify` for a deterministic encoding.
+ */
+declare function computeContentHash(parts: ContentHashParts): string;
+//#endregion
+export { normalizePredicate as i, RlsPolicyOperation as n, computeContentHash as r, ContentHashParts as t };
+//# sourceMappingURL=canonicalize-CAbXtVtB.d.mts.map

package/dist/canonicalize-CAbXtVtB.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalize-CAbXtVtB.d.mts","names":[],"sources":["../src/core/rls/canonicalize.ts"],"mappings":";KAEY,kBAAA;AAAA,UAEK,gBAAA;EAAA,SACN,KAAA;EAAA,SACA,SAAA;EAAA,SACA,KAAA;EAAA,SACA,SAAA,EAAW,kBAAkB;EAAA,SAC7B,UAAA;AAAA;;;;;;;;;;AAAU;AAiBrB;;;;iBAAgB,kBAAA,CAAmB,GAAW;AAa9C;;;;AAA0D;;;;;AAA1D,iBAAgB,kBAAA,CAAmB,KAAuB,EAAhB,gBAAgB"}

package/dist/{codec-ids-CnXu9Qy3.d.mts → codec-ids-BzrFF-I4.d.mts}

@@ -3,6 +3,7 @@ import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC
 //#region src/core/codec-ids.d.ts
 declare const PG_TEXT_CODEC_ID: "pg/text@1";
 declare const PG_TEXT_ARRAY_CODEC_ID: "pg/text-array@1";
+declare const PG_ENUM_CODEC_ID: "pg/enum@1";
 declare const PG_CHAR_CODEC_ID: "pg/char@1";
 declare const PG_VARCHAR_CODEC_ID: "pg/varchar@1";
 declare const PG_INT_CODEC_ID: "pg/int@1";
@@ -26,5 +27,5 @@ declare const PG_JSONB_CODEC_ID: "pg/jsonb@1";
 declare const PG_BYTEA_CODEC_ID: "pg/bytea@1";
 declare const PG_UUID_CODEC_ID: "pg/uuid@1";
 //#endregion
-export { SQL_VARCHAR_CODEC_ID as A, PG_VARBIT_CODEC_ID as C, SQL_INT_CODEC_ID as D, SQL_FLOAT_CODEC_ID as E, SQL_TEXT_CODEC_ID as O, PG_UUID_CODEC_ID as S, SQL_CHAR_CODEC_ID as T, PG_TEXT_CODEC_ID as _, PG_FLOAT4_CODEC_ID as a, PG_TIMETZ_CODEC_ID as b, PG_INT2_CODEC_ID as c, PG_INTERVAL_CODEC_ID as d, PG_INT_CODEC_ID as f, PG_TEXT_ARRAY_CODEC_ID as g, PG_NUMERIC_CODEC_ID as h, PG_CHAR_CODEC_ID as i, SQL_TIMESTAMP_CODEC_ID as k, PG_INT4_CODEC_ID as l, PG_JSON_CODEC_ID as m, PG_BOOL_CODEC_ID as n, PG_FLOAT8_CODEC_ID as o, PG_JSONB_CODEC_ID as p, PG_BYTEA_CODEC_ID as r, PG_FLOAT_CODEC_ID as s, PG_BIT_CODEC_ID as t, PG_INT8_CODEC_ID as u, PG_TIMESTAMPTZ_CODEC_ID as v, PG_VARCHAR_CODEC_ID as w, PG_TIME_CODEC_ID as x, PG_TIMESTAMP_CODEC_ID as y };
-//# sourceMappingURL=codec-ids-CnXu9Qy3.d.mts.map
+export { SQL_TIMESTAMP_CODEC_ID as A, PG_UUID_CODEC_ID as C, SQL_FLOAT_CODEC_ID as D, SQL_CHAR_CODEC_ID as E, SQL_INT_CODEC_ID as O, PG_TIME_CODEC_ID as S, PG_VARCHAR_CODEC_ID as T, PG_TEXT_ARRAY_CODEC_ID as _, PG_ENUM_CODEC_ID as a, PG_TIMESTAMP_CODEC_ID as b, PG_FLOAT_CODEC_ID as c, PG_INT8_CODEC_ID as d, PG_INTERVAL_CODEC_ID as f, PG_NUMERIC_CODEC_ID as g, PG_JSON_CODEC_ID as h, PG_CHAR_CODEC_ID as i, SQL_VARCHAR_CODEC_ID as j, SQL_TEXT_CODEC_ID as k, PG_INT2_CODEC_ID as l, PG_JSONB_CODEC_ID as m, PG_BOOL_CODEC_ID as n, PG_FLOAT4_CODEC_ID as o, PG_INT_CODEC_ID as p, PG_BYTEA_CODEC_ID as r, PG_FLOAT8_CODEC_ID as s, PG_BIT_CODEC_ID as t, PG_INT4_CODEC_ID as u, PG_TEXT_CODEC_ID as v, PG_VARBIT_CODEC_ID as w, PG_TIMETZ_CODEC_ID as x, PG_TIMESTAMPTZ_CODEC_ID as y };
+//# sourceMappingURL=codec-ids-BzrFF-I4.d.mts.map

package/dist/codec-ids-BzrFF-I4.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-BzrFF-I4.d.mts","names":[],"sources":["../src/core/codec-ids.ts"],"mappings":";;;cAQa,gBAAA;AAAA,cACA,sBAAA;AAAA,cACA,gBAAA;AAAA,cACA,gBAAA;AAAA,cACA,mBAAA;AAAA,cACA,eAAA;AAAA,cACA,gBAAA;AAAA,cACA,gBAAA;AAAA,cACA,gBAAA;AAAA,cACA,iBAAA;AAAA,cACA,kBAAA;AAAA,cACA,kBAAA;AAAA,cACA,mBAAA;AAAA,cACA,gBAAA;AAAA,cACA,eAAA;AAAA,cACA,kBAAA;AAAA,cACA,qBAAA;AAAA,cACA,uBAAA;AAAA,cACA,gBAAA;AAAA,cACA,kBAAA;AAAA,cACA,oBAAA;AAAA,cACA,gBAAA;AAAA,cACA,iBAAA;AAAA,cACA,iBAAA;AAAA,cACA,gBAAA"}

package/dist/{codec-ids-BvytN2P8.mjs → codec-ids-C_-Hj6bL.mjs}

@@ -2,6 +2,7 @@ import { SQL_CHAR_CODEC_ID, SQL_FLOAT_CODEC_ID, SQL_INT_CODEC_ID, SQL_TEXT_CODEC
 //#region src/core/codec-ids.ts
 const PG_TEXT_CODEC_ID = "pg/text@1";
 const PG_TEXT_ARRAY_CODEC_ID = "pg/text-array@1";
+const PG_ENUM_CODEC_ID = "pg/enum@1";
 const PG_CHAR_CODEC_ID = "pg/char@1";
 const PG_VARCHAR_CODEC_ID = "pg/varchar@1";
 const PG_INT_CODEC_ID = "pg/int@1";
@@ -25,6 +26,6 @@ const PG_JSONB_CODEC_ID = "pg/jsonb@1";
 const PG_BYTEA_CODEC_ID = "pg/bytea@1";
 const PG_UUID_CODEC_ID = "pg/uuid@1";
 //#endregion
-export { SQL_VARCHAR_CODEC_ID as A, PG_VARBIT_CODEC_ID as C, SQL_INT_CODEC_ID as D, SQL_FLOAT_CODEC_ID as E, SQL_TEXT_CODEC_ID as O, PG_UUID_CODEC_ID as S, SQL_CHAR_CODEC_ID as T, PG_TEXT_CODEC_ID as _, PG_FLOAT4_CODEC_ID as a, PG_TIMETZ_CODEC_ID as b, PG_INT2_CODEC_ID as c, PG_INTERVAL_CODEC_ID as d, PG_INT_CODEC_ID as f, PG_TEXT_ARRAY_CODEC_ID as g, PG_NUMERIC_CODEC_ID as h, PG_CHAR_CODEC_ID as i, SQL_TIMESTAMP_CODEC_ID as k, PG_INT4_CODEC_ID as l, PG_JSON_CODEC_ID as m, PG_BOOL_CODEC_ID as n, PG_FLOAT8_CODEC_ID as o, PG_JSONB_CODEC_ID as p, PG_BYTEA_CODEC_ID as r, PG_FLOAT_CODEC_ID as s, PG_BIT_CODEC_ID as t, PG_INT8_CODEC_ID as u, PG_TIMESTAMPTZ_CODEC_ID as v, PG_VARCHAR_CODEC_ID as w, PG_TIME_CODEC_ID as x, PG_TIMESTAMP_CODEC_ID as y };
+export { SQL_TIMESTAMP_CODEC_ID as A, PG_UUID_CODEC_ID as C, SQL_FLOAT_CODEC_ID as D, SQL_CHAR_CODEC_ID as E, SQL_INT_CODEC_ID as O, PG_TIME_CODEC_ID as S, PG_VARCHAR_CODEC_ID as T, PG_TEXT_ARRAY_CODEC_ID as _, PG_ENUM_CODEC_ID as a, PG_TIMESTAMP_CODEC_ID as b, PG_FLOAT_CODEC_ID as c, PG_INT8_CODEC_ID as d, PG_INTERVAL_CODEC_ID as f, PG_NUMERIC_CODEC_ID as g, PG_JSON_CODEC_ID as h, PG_CHAR_CODEC_ID as i, SQL_VARCHAR_CODEC_ID as j, SQL_TEXT_CODEC_ID as k, PG_INT2_CODEC_ID as l, PG_JSONB_CODEC_ID as m, PG_BOOL_CODEC_ID as n, PG_FLOAT4_CODEC_ID as o, PG_INT_CODEC_ID as p, PG_BYTEA_CODEC_ID as r, PG_FLOAT8_CODEC_ID as s, PG_BIT_CODEC_ID as t, PG_INT4_CODEC_ID as u, PG_TEXT_CODEC_ID as v, PG_VARBIT_CODEC_ID as w, PG_TIMETZ_CODEC_ID as x, PG_TIMESTAMPTZ_CODEC_ID as y };
 
-//# sourceMappingURL=codec-ids-BvytN2P8.mjs.map
+//# sourceMappingURL=codec-ids-C_-Hj6bL.mjs.map

package/dist/codec-ids-C_-Hj6bL.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-ids-C_-Hj6bL.mjs","names":[],"sources":["../src/core/codec-ids.ts"],"sourcesContent":["export {\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/sql-relational-core/ast';\nexport const PG_TEXT_CODEC_ID = 'pg/text@1' as const;\nexport const PG_TEXT_ARRAY_CODEC_ID = 'pg/text-array@1' as const;\nexport const PG_ENUM_CODEC_ID = 'pg/enum@1' as const;\nexport const PG_CHAR_CODEC_ID = 'pg/char@1' as const;\nexport const PG_VARCHAR_CODEC_ID = 'pg/varchar@1' as const;\nexport const PG_INT_CODEC_ID = 'pg/int@1' as const;\nexport const PG_INT2_CODEC_ID = 'pg/int2@1' as const;\nexport const PG_INT4_CODEC_ID = 'pg/int4@1' as const;\nexport const PG_INT8_CODEC_ID = 'pg/int8@1' as const;\nexport const PG_FLOAT_CODEC_ID = 'pg/float@1' as const;\nexport const PG_FLOAT4_CODEC_ID = 'pg/float4@1' as const;\nexport const PG_FLOAT8_CODEC_ID = 'pg/float8@1' as const;\nexport const PG_NUMERIC_CODEC_ID = 'pg/numeric@1' as const;\nexport const PG_BOOL_CODEC_ID = 'pg/bool@1' as const;\nexport const PG_BIT_CODEC_ID = 'pg/bit@1' as const;\nexport const PG_VARBIT_CODEC_ID = 'pg/varbit@1' as const;\nexport const PG_TIMESTAMP_CODEC_ID = 'pg/timestamp@1' as const;\nexport const PG_TIMESTAMPTZ_CODEC_ID = 'pg/timestamptz@1' as const;\nexport const PG_TIME_CODEC_ID = 'pg/time@1' as const;\nexport const PG_TIMETZ_CODEC_ID = 'pg/timetz@1' as const;\nexport const PG_INTERVAL_CODEC_ID = 'pg/interval@1' as const;\nexport const PG_JSON_CODEC_ID = 'pg/json@1' as const;\nexport const PG_JSONB_CODEC_ID = 'pg/jsonb@1' as const;\nexport const PG_BYTEA_CODEC_ID = 'pg/bytea@1' as const;\nexport const PG_UUID_CODEC_ID = 'pg/uuid@1' as const;\n"],"mappings":";;AAQA,MAAa,mBAAmB;AAChC,MAAa,yBAAyB;AACtC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,sBAAsB;AACnC,MAAa,kBAAkB;AAC/B,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB;AACjC,MAAa,qBAAqB;AAClC,MAAa,qBAAqB;AAClC,MAAa,sBAAsB;AACnC,MAAa,mBAAmB;AAChC,MAAa,kBAAkB;AAC/B,MAAa,qBAAqB;AAClC,MAAa,wBAAwB;AACrC,MAAa,0BAA0B;AACvC,MAAa,mBAAmB;AAChC,MAAa,qBAAqB;AAClC,MAAa,uBAAuB;AACpC,MAAa,mBAAmB;AAChC,MAAa,oBAAoB;AACjC,MAAa,oBAAoB;AACjC,MAAa,mBAAmB"}

package/dist/codec-ids.d.mts

@@ -1,2 +1,2 @@
-import { A as SQL_VARCHAR_CODEC_ID, C as PG_VARBIT_CODEC_ID, D as SQL_INT_CODEC_ID, E as SQL_FLOAT_CODEC_ID, O as SQL_TEXT_CODEC_ID, S as PG_UUID_CODEC_ID, T as SQL_CHAR_CODEC_ID, _ as PG_TEXT_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIMETZ_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, f as PG_INT_CODEC_ID, g as PG_TEXT_ARRAY_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_CHAR_CODEC_ID, k as SQL_TIMESTAMP_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMPTZ_CODEC_ID, w as PG_VARCHAR_CODEC_ID, x as PG_TIME_CODEC_ID, y as PG_TIMESTAMP_CODEC_ID } from "./codec-ids-CnXu9Qy3.mjs";
-export { 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_ARRAY_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_UUID_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 };
+import { A as SQL_TIMESTAMP_CODEC_ID, C as PG_UUID_CODEC_ID, D as SQL_FLOAT_CODEC_ID, E as SQL_CHAR_CODEC_ID, O as SQL_INT_CODEC_ID, S as PG_TIME_CODEC_ID, T as PG_VARCHAR_CODEC_ID, _ as PG_TEXT_ARRAY_CODEC_ID, a as PG_ENUM_CODEC_ID, b as PG_TIMESTAMP_CODEC_ID, c as PG_FLOAT_CODEC_ID, d as PG_INT8_CODEC_ID, f as PG_INTERVAL_CODEC_ID, g as PG_NUMERIC_CODEC_ID, h as PG_JSON_CODEC_ID, i as PG_CHAR_CODEC_ID, j as SQL_VARCHAR_CODEC_ID, k as SQL_TEXT_CODEC_ID, l as PG_INT2_CODEC_ID, m as PG_JSONB_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT4_CODEC_ID, p as PG_INT_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT8_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT4_CODEC_ID, v as PG_TEXT_CODEC_ID, w as PG_VARBIT_CODEC_ID, x as PG_TIMETZ_CODEC_ID, y as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-BzrFF-I4.mjs";
+export { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_BYTEA_CODEC_ID, PG_CHAR_CODEC_ID, PG_ENUM_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_ARRAY_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_UUID_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 };

package/dist/codec-ids.mjs

@@ -1,2 +1,2 @@
-import { A as SQL_VARCHAR_CODEC_ID, C as PG_VARBIT_CODEC_ID, D as SQL_INT_CODEC_ID, E as SQL_FLOAT_CODEC_ID, O as SQL_TEXT_CODEC_ID, S as PG_UUID_CODEC_ID, T as SQL_CHAR_CODEC_ID, _ as PG_TEXT_CODEC_ID, a as PG_FLOAT4_CODEC_ID, b as PG_TIMETZ_CODEC_ID, c as PG_INT2_CODEC_ID, d as PG_INTERVAL_CODEC_ID, f as PG_INT_CODEC_ID, g as PG_TEXT_ARRAY_CODEC_ID, h as PG_NUMERIC_CODEC_ID, i as PG_CHAR_CODEC_ID, k as SQL_TIMESTAMP_CODEC_ID, l as PG_INT4_CODEC_ID, m as PG_JSON_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT8_CODEC_ID, p as PG_JSONB_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT8_CODEC_ID, v as PG_TIMESTAMPTZ_CODEC_ID, w as PG_VARCHAR_CODEC_ID, x as PG_TIME_CODEC_ID, y as PG_TIMESTAMP_CODEC_ID } from "./codec-ids-BvytN2P8.mjs";
-export { 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_ARRAY_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_UUID_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 };
+import { A as SQL_TIMESTAMP_CODEC_ID, C as PG_UUID_CODEC_ID, D as SQL_FLOAT_CODEC_ID, E as SQL_CHAR_CODEC_ID, O as SQL_INT_CODEC_ID, S as PG_TIME_CODEC_ID, T as PG_VARCHAR_CODEC_ID, _ as PG_TEXT_ARRAY_CODEC_ID, a as PG_ENUM_CODEC_ID, b as PG_TIMESTAMP_CODEC_ID, c as PG_FLOAT_CODEC_ID, d as PG_INT8_CODEC_ID, f as PG_INTERVAL_CODEC_ID, g as PG_NUMERIC_CODEC_ID, h as PG_JSON_CODEC_ID, i as PG_CHAR_CODEC_ID, j as SQL_VARCHAR_CODEC_ID, k as SQL_TEXT_CODEC_ID, l as PG_INT2_CODEC_ID, m as PG_JSONB_CODEC_ID, n as PG_BOOL_CODEC_ID, o as PG_FLOAT4_CODEC_ID, p as PG_INT_CODEC_ID, r as PG_BYTEA_CODEC_ID, s as PG_FLOAT8_CODEC_ID, t as PG_BIT_CODEC_ID, u as PG_INT4_CODEC_ID, v as PG_TEXT_CODEC_ID, w as PG_VARBIT_CODEC_ID, x as PG_TIMETZ_CODEC_ID, y as PG_TIMESTAMPTZ_CODEC_ID } from "./codec-ids-C_-Hj6bL.mjs";
+export { PG_BIT_CODEC_ID, PG_BOOL_CODEC_ID, PG_BYTEA_CODEC_ID, PG_CHAR_CODEC_ID, PG_ENUM_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_ARRAY_CODEC_ID, PG_TEXT_CODEC_ID, PG_TIMESTAMPTZ_CODEC_ID, PG_TIMESTAMP_CODEC_ID, PG_TIMETZ_CODEC_ID, PG_TIME_CODEC_ID, PG_UUID_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 };

package/dist/{codec-types-DHCkwPKE.d.mts → codec-types-BDVmvKAW.d.mts}

@@ -1,4 +1,4 @@
-import { C as PgVarcharDescriptor, S as PgVarbitDescriptor, _ as PgTimeDescriptor, a as PgFloat4Descriptor, b as PgTimetzDescriptor, c as PgInt2Descriptor, d as PgIntDescriptor, f as PgIntervalDescriptor, g as PgTextDescriptor, h as PgNumericDescriptor, i as PgCharDescriptor, l as PgInt4Descriptor, m as PgJsonbDescriptor, n as PgBoolDescriptor, o as PgFloat8Descriptor, p as PgJsonDescriptor, r as PgByteaDescriptor, s as PgFloatDescriptor, t as PgBitDescriptor, u as PgInt8Descriptor, v as PgTimestampDescriptor, x as PgUuidDescriptor, y as PgTimestamptzDescriptor } from "./codecs--0A5_4Bq.mjs";
+import { C as PgVarbitDescriptor, S as PgUuidDescriptor, _ as PgTextDescriptor, a as PgEnumDescriptor, b as PgTimestamptzDescriptor, c as PgFloatDescriptor, d as PgInt8Descriptor, f as PgIntDescriptor, g as PgNumericDescriptor, h as PgJsonbDescriptor, i as PgCharDescriptor, l as PgInt2Descriptor, m as PgJsonDescriptor, n as PgBoolDescriptor, o as PgFloat4Descriptor, p as PgIntervalDescriptor, r as PgByteaDescriptor, s as PgFloat8Descriptor, t as PgBitDescriptor, u as PgInt4Descriptor, v as PgTimeDescriptor, w as PgVarcharDescriptor, x as PgTimetzDescriptor, y as PgTimestampDescriptor } from "./codecs-Dk2sxGLv.mjs";
 import { ExtractCodecTypes } from "@prisma-next/sql-relational-core/ast";
 import { JsonValue as JsonValue$1 } from "@prisma-next/contract/types";
 
@@ -11,6 +11,7 @@ declare const codecDescriptorMap: {
   readonly 'sql-text': import("@prisma-next/sql-relational-core/ast").SqlTextDescriptor;
   readonly 'sql-timestamp': import("@prisma-next/sql-relational-core/ast").SqlTimestampDescriptor;
   readonly text: PgTextDescriptor;
+  readonly enum: PgEnumDescriptor;
   readonly character: PgCharDescriptor;
   readonly 'character varying': PgVarcharDescriptor;
   readonly integer: PgIntDescriptor;
@@ -75,4 +76,4 @@ type Interval<P extends number | undefined = undefined> = BrandedString<{
 }>;
 //#endregion
 export { JsonValue$1 as a, Timestamp as c, VarBit as d, Varchar as f, Interval as i, Timestamptz as l, Char as n, Numeric as o, CodecTypes as r, Time as s, Bit as t, Timetz as u };
-//# sourceMappingURL=codec-types-DHCkwPKE.d.mts.map
+//# sourceMappingURL=codec-types-BDVmvKAW.d.mts.map

package/dist/codec-types-BDVmvKAW.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-types-BDVmvKAW.d.mts","names":[],"sources":["../src/core/codec-type-map.ts","../src/exports/codec-types.ts"],"mappings":";;;;;cA6Ca,kBAAA;EAAA;;;;;;iBA+BH,gBAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;;KAEE,OAAA,6BAAoC,CAAA,0BAA2B,CAAA,CAAE,CAAA,IAAK,CAAA,CAAE,CAAA,EAAG,CAAA;AAAA,KAE3E,kBAAA,UAA4B,kBAAkB;AAAA,KAE9C,mBAAA,GAAsB,iBAAiB,CAAC,kBAAA;;;KCvExC,UAAA,GAAa,OAAO,CAAC,mBAAA;AAAA,KAI5B,OAAA,kBAAyB,MAAA,qBAA2B,CAAA,0BAClC,KAAA,GAAQ,KAAA,CAAM,CAAA;AAAA,KAGhC,aAAA,eAA4B,MAAA,qBAA2B,OAAA,SAAgB,KAAA;AAAA,KAEhE,IAAA,qBAAyB,aAAa;EAAG,YAAA,EAAc,CAAA;AAAA;AAAA,KACvD,OAAA,qBAA4B,aAAa;EAAG,eAAA,EAAiB,CAAA;AAAA;AAAA,KAC7D,OAAA,+DAAsE,aAAA;EAChF,kBAAA,EAAoB,CAAA;EACpB,cAAA,EAAgB,CAAA;AAAA;AAAA,KAEN,GAAA,qBAAwB,aAAa;EAAG,WAAA,EAAa,CAAA;AAAA;AAAA,KACrD,MAAA,qBAA2B,aAAa;EAAG,cAAA,EAAgB,CAAA;AAAA;AAAA,KAC3D,SAAA,6CAAsD,aAAa;EAC7E,oBAAA,EAAsB,CAAA;AAAA;AAAA,KAEZ,WAAA,6CAAwD,aAAa;EAC/E,sBAAA,EAAwB,CAAA;AAAA;AAAA,KAEd,IAAA,6CAAiD,aAAa;EAAG,eAAA,EAAiB,CAAA;AAAA;AAAA,KAClF,MAAA,6CAAmD,aAAa;EAC1E,iBAAA,EAAmB,CAAA;AAAA;AAAA,KAET,QAAA,6CAAqD,aAAa;EAC5E,mBAAA,EAAqB,CAAA;AAAA"}

package/dist/codec-types.d.mts

@@ -1,2 +1,2 @@
-import { a as JsonValue, c as Timestamp, d as VarBit, f as Varchar, i as Interval, l as Timestamptz, n as Char, o as Numeric, r as CodecTypes, s as Time, t as Bit, u as Timetz } from "./codec-types-DHCkwPKE.mjs";
+import { a as JsonValue, c as Timestamp, d as VarBit, f as Varchar, i as Interval, l as Timestamptz, n as Char, o as Numeric, r as CodecTypes, s as Time, t as Bit, u as Timetz } from "./codec-types-BDVmvKAW.mjs";
 export { Bit, Char, CodecTypes, Interval, type JsonValue, Numeric, Time, Timestamp, Timestamptz, Timetz, VarBit, Varchar };