@prisma/orm-family-sql 8.0.0-rc.20-dev.13 → 8.0.0-rc.20-dev.15

package/dist/{contract-builder-50lF0kz1.mjs → contract-builder-DMNe_jX9.mjs}

@@ -1,18 +1,19 @@
 import { d as sqlColumnLength } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
 import { t as providesEntityHandleLowering } from "./entity-handle-lowering-hook-BJZSlVVF.mjs";
+import { n as generatedIdColumnAliases, t as GENERATED_ID_COLUMN_ALIAS_NAMESPACES } from "./generated-id-column-aliases-DPUii1fN.mjs";
 import { a as isSqlExpression, c as requireSqlExpression, r as SqlExpression, s as readSqlExpression } from "./sql-expression-CKgKznXS.mjs";
 import { t as CODEC_INSTANCE_KIND } from "./types-CTdSkl0s.mjs";
 import { n as checkSqlDefaultText, o as reservedSqlDefaultText } from "./validators-BwA7ttZM.mjs";
 import { a as refuseTypesKey, n as buildSqlContractFromDefinition, r as contractError, s as toOneNullabilityContradictionMessage } from "./derived-checks-D5HVRvqN-BJx1gwPA.mjs";
 import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-import { assembleDataTypeSupport, assertNoCrossRegistryCollisions, assertTypeAliasesValid, describeAdmittedForms, instantiateAuthoringFieldPreset, instantiateAuthoringTypeAlias, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringTypeAliasDescriptor, isAuthoringTypeConstructorDescriptor, readWrittenValueAs, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
+import { assembleDataTypeSupport, assertNoCrossRegistryCollisions, assertTypeAliasesValid, describeAdmittedForms, instantiateAuthoringTypeAlias, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringTypeAliasDescriptor, isAuthoringTypeConstructorDescriptor, isAuthoringTypeDescriptor, readWrittenValueAs, validateAuthoringHelperArguments, validateAuthoringTypeParams } from "@prisma/orm-framework/components/authoring";
 import { dataTypeId, numeralText } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { isColumnDefault } from "@prisma/orm-framework/contract/types";
 import { assembleGeneratorFunctions, createGeneratorHelpers } from "@prisma/orm-framework/components/components";
-import { assertSafeAuthoringHelperKey, bindEnumType, composePackAuthoringNamespace, createEntityHelpersFromNamespace, createFieldHelpersFromNamespace, enumType, isEnumTypeHandle, member, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { answerMissingPropertyReads, assertSafeAuthoringHelperKey, bindEnumType, composePackAuthoringNamespace, createEntityHelpersFromNamespace, enumType, isEnumTypeHandle, member, resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
 import { UNBOUND_PSL_NAMESPACE_NAME } from "@prisma/orm-framework/components/psl-ast";
 //#region ../../../2-sql-family/2-authoring/contract-ts/dist/contract-builder.mjs
 /** The written value a TypeScript argument stands for: a number, string or boolean as written in PSL, and a `sql` value as a `sql` literal of its text. */
@@ -46,21 +47,15 @@ function readValueArgument(label, value, dataType, dataTypes) {
 	return read.ok ? read.value.value : refuse(read.failure.message);
 }
 /**
-* The arguments of a type constructor or field preset call as the constructor receives them: each `value` argument read as a value of its data type, through the same read and cast as a PSL argument, so both give the same parameters. ADR 129, ADR 254.
+* The arguments of a type constructor call as the constructor receives them: each `value` argument read as a value of its data type, through the same read and cast as a PSL argument, so both give the same parameters. ADR 129, ADR 254.
 */
 function readValueArguments(helperPath, descriptors, args, dataTypes) {
 	return args.map((value, index) => {
 		const descriptor = descriptors?.[index];
-		if (descriptor?.kind !== "value" || value === void 0) return value;
+		if (descriptor === void 0 || value === void 0) return value;
 		return readValueArgument(descriptor.name === void 0 ? `Argument #${index + 1} of ${helperPath}` : `Argument "${descriptor.name}" of ${helperPath}`, value, dataTypeId(descriptor.dataType), dataTypes);
 	});
 }
-function isNamedConstraintOptionsLike(value) {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-	if (Object.keys(value).some((key) => key !== "name")) return false;
-	const name = value.name;
-	return name === void 0 || typeof name === "string";
-}
 function createTypeHelpersFromNamespace(namespace, lookups, path = []) {
 	const helpers = {};
 	for (const [key, value] of Object.entries(namespace)) {
@@ -103,35 +98,8 @@ function createTypeHelpersFromNamespace(namespace, lookups, path = []) {
 	}
 	return helpers;
 }
-function createFieldPresetHelper(options) {
-	return (...rawArgs) => {
-		const acceptsNamedConstraintOptions = options.descriptor.output.id === true || options.descriptor.output.unique === true;
-		const declaredArguments = options.descriptor.args ?? [];
-		if (acceptsNamedConstraintOptions && rawArgs.length > declaredArguments.length + 1) throw contractError("CONTRACT.ARGUMENT_INVALID", `${options.helperPath} expects at most ${declaredArguments.length + 1} argument(s), received ${rawArgs.length}`, { meta: {
-			helperPath: options.helperPath,
-			expected: declaredArguments.length + 1,
-			received: rawArgs.length
-		} });
-		let args = rawArgs;
-		let namedConstraintOptions;
-		if (acceptsNamedConstraintOptions && rawArgs.length === declaredArguments.length + 1) {
-			const maybeNamedConstraintOptions = rawArgs.at(-1);
-			if (!isNamedConstraintOptionsLike(maybeNamedConstraintOptions)) throw contractError("CONTRACT.ARGUMENT_INVALID", `${options.helperPath} accepts an optional trailing { name?: string } constraint options object`, { meta: { helperPath: options.helperPath } });
-			namedConstraintOptions = maybeNamedConstraintOptions;
-			args = rawArgs.slice(0, -1);
-		}
-		validateAuthoringHelperArguments(options.helperPath, options.descriptor.args, args);
-		const values = readValueArguments(options.helperPath, options.descriptor.args, args, options.dataTypes);
-		const output = options.descriptor.output;
-		validateAuthoringTypeParams(options.helperPath, output, instantiateAuthoringFieldPreset(options.descriptor, values).descriptor.typeParams, options.codecLookup.descriptorFor(output.codecId)?.paramsSchema);
-		return options.build({
-			args: values,
-			...namedConstraintOptions ? { namedConstraintOptions } : {}
-		});
-	};
-}
 function withGeneratorCall(state, phase, call) {
-	if (state.generatorCalls?.[phase] !== void 0 || state.executionDefaults?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a field preset, type alias or alias constant that sets it.`, { meta: {
+	if (state.generatorCalls?.[phase] !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `.${phase}() is called on a field that already generates a value ${phase === "onCreate" ? "on create" : "on update"}. Set each phase once, and do not combine .${phase}() with a type alias or alias constant that sets it.`, { meta: {
 		reason: "generator-phase-set-twice",
 		phase
 	} });
@@ -144,7 +112,7 @@ function withGeneratorCall(state, phase, call) {
 	};
 }
 function withColumnDefault(state, columnDefault) {
-	if (state.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", ".default() is called on a field that already has a default. Set the default once, and do not combine .default() with a field preset or alias constant that sets one.", { meta: { reason: "default-set-twice" } });
+	if (state.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", ".default() is called on a field that already has a default. Set the default once, and do not combine .default() with an alias constant that sets one.", { meta: { reason: "default-set-twice" } });
 	return {
 		...state,
 		default: columnDefault
@@ -290,37 +258,12 @@ const columnField = (descriptor) => {
 		...ifDefined("generatorCalls", generatorCalls)
 	});
 };
-function generatedField(spec) {
-	return new ScalarFieldBuilder({
-		kind: "scalar",
-		descriptor: blindCast({
-			...spec.type,
-			...spec.typeParams ? { typeParams: spec.typeParams } : {}
-		}),
-		nullable: false,
-		many: false,
-		executionDefaults: { onCreate: spec.generated }
-	});
-}
 const namedTypeField = (handle) => new EnumScalarFieldBuilder(blindCast({
 	kind: "scalar",
 	enumHandle: handle,
 	nullable: false,
 	many: false
 }), handle);
-function buildFieldPreset(descriptor, args, namedConstraintOptions) {
-	const preset = instantiateAuthoringFieldPreset(descriptor, args);
-	return new ScalarFieldBuilder({
-		kind: "scalar",
-		descriptor: preset.descriptor,
-		nullable: preset.nullable,
-		many: false,
-		...ifDefined("default", preset.default),
-		...ifDefined("executionDefaults", preset.executionDefaults),
-		...preset.id ? { id: namedConstraintOptions?.name ? { name: namedConstraintOptions.name } : {} } : {},
-		...preset.unique ? { unique: namedConstraintOptions?.name ? { name: namedConstraintOptions.name } : {} } : {}
-	});
-}
 var RelationBuilder = class RelationBuilder {
 	state;
 	constructor(state) {
@@ -676,7 +619,6 @@ const rel = {
 };
 const field = {
 	column: columnField,
-	generated: generatedField,
 	namedType: namedTypeField
 };
 function isContractInput(value) {
@@ -714,12 +656,104 @@ function applyNaming(name, strategy) {
 	}
 	return result;
 }
+const GUIDE = "The upgrade guide \"Field presets are removed\" lists every rewrite.";
+/** The row of a preset whose rewrite is `rewrite`; its type is the first `type.X(` that `rewrite` writes. */
+function writtenAs(rewrite, codecId) {
+	return [{
+		type: (/type\.([\w.]+)\(/.exec(rewrite)?.[1] ?? "").split("."),
+		codecId,
+		rewrite
+	}];
+}
+/** The `type.` prefix of a namespace, such as `sql.` for `['sql']`. */
+const prefixOf = (namespace) => namespace.map((name) => `${name}.`).join("");
+/** The rows of a preset whose rewrite `write` makes from each namespace's `type.` prefix, each named where that namespace has the generated id column alias `alias`. */
+function idAlias(alias, write) {
+	return GENERATED_ID_COLUMN_ALIAS_NAMESPACES.map((namespace) => ({
+		type: [...namespace, alias],
+		codecId: generatedIdColumnAliases[alias].output.type.codecId,
+		rewrite: write(prefixOf(namespace))
+	}));
+}
+const column$1 = (prefix, type) => `field.column(type.${prefix}${type})`;
+const id = (columnText, generator) => `${columnText}.id().onCreate(gen.${generator})`;
+const aliasColumn = (alias) => idAlias(alias, (prefix) => column$1(prefix, `${alias}()`));
+const aliasId = (alias, generator) => idAlias(alias, (prefix) => id(column$1(prefix, `${alias}()`), generator));
+const withPhases = (type, codecId, precision) => writtenAs(`field.column(type.${type}(${precision ? "p" : ""})), with .onCreate(gen.now()) and .onUpdate(gen.now()) for the phases the preset set${precision ? ", and without p when it set no precision" : ""}`, codecId);
+const PRESETS = {
+	uuidString: aliasColumn("UuidString"),
+	ulid: aliasColumn("Ulid"),
+	nanoid: idAlias("Nanoid", (prefix) => `${column$1(prefix, "Nanoid()")}, or ${column$1(prefix, "Char(n)")} for nanoid({ size: n })`),
+	cuid2: aliasColumn("Cuid2"),
+	ksuid: aliasColumn("Ksuid"),
+	text: writtenAs("field.column(type.String())", "pg/text@1"),
+	int: writtenAs("field.column(type.Int())", "pg/int4@1"),
+	bigint: writtenAs("field.column(type.BigInt())", "pg/int8@1"),
+	float: writtenAs("field.column(type.Float())", "pg/float8@1"),
+	decimal: writtenAs("field.column(type.Decimal())", "pg/numeric@1"),
+	boolean: writtenAs("field.column(type.Boolean())", "pg/bool@1"),
+	json: writtenAs("field.column(type.Jsonb())", "pg/jsonb@1"),
+	bytes: writtenAs("field.column(type.Bytes())", "pg/bytea@1"),
+	dateTime: writtenAs("field.column(type.DateTime())", "pg/timestamptz-temporal@1"),
+	uuidNative: writtenAs("field.column(type.Uuid())", "pg/uuid@1"),
+	generated: idAlias("UuidString", (prefix) => `${column$1(prefix, "Char(n)")}.onCreate(gen.fn()), such as ${column$1(prefix, "UuidString()")}.onCreate(gen.uuid()) for field.generated(uuidv4())`),
+	"id.uuidv4String": aliasId("UuidString", "uuid()"),
+	"id.uuidv7String": aliasId("UuidString", "uuid(7)"),
+	"id.ulid": aliasId("Ulid", "ulid()"),
+	"id.nanoid": idAlias("Nanoid", (prefix) => `${id(column$1(prefix, "Nanoid()"), "nanoid()")}, or ${id(column$1(prefix, "Char(n)"), "nanoid(n)")} for id.nanoid({ size: n })`),
+	"id.cuid2": aliasId("Cuid2", "cuid(2)"),
+	"id.ksuid": aliasId("Ksuid", "ksuid()"),
+	"id.uuidv4Native": writtenAs(id("field.column(type.Uuid())", "uuid()"), "pg/uuid@1"),
+	"id.uuidv7Native": writtenAs(id("field.column(type.Uuid())", "uuid(7)"), "pg/uuid@1"),
+	"temporal.createdAt": writtenAs("field.column(type.temporal.CreatedAt())"),
+	"temporal.updatedAt": writtenAs("field.column(type.temporal.UpdatedAt())"),
+	"temporal.createdAtString": writtenAs("field.column(type.temporal.CreatedAtString())"),
+	"temporal.updatedAtString": writtenAs("field.column(type.temporal.UpdatedAtString())"),
+	"temporal.createdAtJsDate": writtenAs("field.column(type.temporal.CreatedAtJsDate())"),
+	"temporal.updatedAtJsDate": writtenAs("field.column(type.temporal.UpdatedAtJsDate())"),
+	"temporal.timestamp": withPhases("TimestampTemporal", "pg/timestamp-temporal@1", true),
+	"temporal.timestamptz": withPhases("TimestamptzTemporal", "pg/timestamptz-temporal@1", true),
+	"temporal.timestampString": withPhases("TimestampString", "pg/timestamp-string@1", true),
+	"temporal.timestamptzString": withPhases("TimestamptzString", "pg/timestamptz-string@1", true),
+	"temporal.timestamptzJsDate": withPhases("TimestamptzJsDate", "pg/timestamptz-date@1", true),
+	"temporal.date": withPhases("Date", "pg/date-temporal@1", false),
+	"temporal.dateString": withPhases("DateString", "pg/date-string@1", false),
+	"temporal.time": withPhases("Time", "pg/time-temporal@1", true),
+	"temporal.timeString": withPhases("TimeString", "pg/time-string@1", true),
+	"temporal.timetz": withPhases("Timetz", "pg/timetz@1", true),
+	"temporal.datetime": withPhases("DateTime", "sqlite/datetime@1", false)
+};
+function codecIdAt(types, path) {
+	const [name, ...rest] = path;
+	if (name === void 0 || !Object.hasOwn(types, name)) return void 0;
+	const value = types[name];
+	if (value === void 0) return void 0;
+	if (!isAuthoringTypeDescriptor(value)) return codecIdAt(value, rest);
+	if (rest.length > 0) return void 0;
+	return isAuthoringTypeAliasDescriptor(value) ? value.output.type.codecId : value.output.codecId;
+}
+function appliesTo(preset, types) {
+	const codecId = codecIdAt(types, preset.type);
+	return codecId !== void 0 && (preset.codecId === void 0 || codecId === preset.codecId);
+}
+function refuse(path, types) {
+	const helper = `field.${path}`;
+	const preset = (Object.hasOwn(PRESETS, path) ? PRESETS[path] : void 0)?.find((row) => appliesTo(row, types));
+	throw contractError("CONTRACT.FIELD_HELPER_UNKNOWN", preset !== void 0 ? `${helper} was a field preset, and Prisma 8 removed field presets. Write ${preset.rewrite}. ${GUIDE}` : `${helper} does not exist. Prisma 8 removed field presets: declare a column as field.column(type.X(...)), add .id(), .onCreate(gen.fn()) and .onUpdate(gen.fn()) for what a preset set, or use a type alias such as field.column(type.temporal.CreatedAt()). ${GUIDE}`, { meta: { helper } });
+}
+function membersOf(namespace) {
+	return new Set(Object.keys(PRESETS).filter((path) => path.startsWith(`${namespace}.`)).map((path) => path.slice(namespace.length + 1)));
+}
+const NAMES = new Set(Object.keys(PRESETS).map((path) => path.split(".")[0] ?? path));
+/**
+* The SQL `field` helpers, where a read of a removed field preset throws `CONTRACT.FIELD_HELPER_UNKNOWN`, so a JavaScript caller, or a contract emitted before it is type-checked, learns what to write instead. The rewrite is named where `types`, the stack's `type` namespace, has the type it writes and that type stores the preset's codec; elsewhere the message names the forms that replace presets. `field.id` and `field.temporal`, which held presets, answer the same way for the presets read from them. Every other read behaves as on `helpers`.
+*/
+function refusingRemovedFieldPresets(helpers, types) {
+	return answerMissingPropertyReads(helpers, NAMES, (name) => Object.hasOwn(PRESETS, name) ? refuse(name, types) : answerMissingPropertyReads({}, membersOf(name), (member) => refuse(`${name}.${member}`, types)));
+}
 function composeTypeNamespace(components) {
 	return composePackAuthoringNamespace(components, "type");
 }
-function composeFieldNamespace(components) {
-	return composePackAuthoringNamespace(components, "field");
-}
 function composeEntityNamespace(components) {
 	return composePackAuthoringNamespace(components, "entityTypes");
 }
@@ -746,26 +780,6 @@ function assertNoBuiltInEntityCollisions(namespace) {
 		reservedKeys: RESERVED_HELPER_KEYS
 	} });
 }
-function createComposedFieldHelpers(fieldNamespace, lookups) {
-	const helperNamespace = createFieldHelpersFromNamespace(fieldNamespace, ({ helperPath, descriptor }) => createFieldPresetHelper({
-		helperPath,
-		descriptor,
-		codecLookup: lookups.codecLookup,
-		dataTypes: lookups.dataTypes,
-		build: ({ args, namedConstraintOptions }) => buildFieldPreset(descriptor, args, namedConstraintOptions)
-	}));
-	const coreFieldHelpers = {
-		column: field.column,
-		generated: field.generated,
-		namedType: field.namedType
-	};
-	const coreHelperNames = new Set(Object.keys(coreFieldHelpers));
-	for (const helperName of Object.keys(helperNamespace)) if (coreHelperNames.has(helperName)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Duplicate authoring field helper "${helperName}". Core field helpers reserve that name.`, { meta: { helperName } });
-	return {
-		...coreFieldHelpers,
-		...helperNamespace
-	};
-}
 function createComposedAuthoringHelpers(options) {
 	const extensionValues = Object.values(options.extensions ?? {});
 	const components = [
@@ -774,9 +788,8 @@ function createComposedAuthoringHelpers(options) {
 		...extensionValues
 	];
 	const typeNamespace = composeTypeNamespace(components);
-	const fieldNamespace = composeFieldNamespace(components);
 	const entityNamespace = composeEntityNamespace(components);
-	assertNoCrossRegistryCollisions(typeNamespace, fieldNamespace, entityNamespace);
+	assertNoCrossRegistryCollisions(typeNamespace, entityNamespace);
 	assertNoBuiltInEntityCollisions(entityNamespace);
 	const { support } = assembleDataTypeSupport(components, (codecId) => options.codecLookup.descriptorFor(codecId)?.dataType);
 	const helperLookups = {
@@ -790,7 +803,7 @@ function createComposedAuthoringHelpers(options) {
 			codecLookup: options.codecLookup,
 			dataTypes: support
 		} }),
-		field: createComposedFieldHelpers(fieldNamespace, helperLookups),
+		field: refusingRemovedFieldPresets(field, typeNamespace),
 		model,
 		rel,
 		type: createTypeHelpersFromNamespace(typeNamespace, helperLookups),
@@ -881,7 +894,7 @@ function emitTypedCrossModelFallbackWarnings(collection) {
 	}
 	flushWarnings(warnings);
 }
-/** A column stores no `typeParams` when it has none, as PSL writes it (ADR 246). */
+/** A column stores no `typeParams` when it has none, as PSL writes it (see "Deterministic emission" in `docs/architecture docs/subsystems/1. Data Contract.md`). */
 function withoutEmptyTypeParams(descriptor) {
 	const { typeParams, ...rest } = descriptor;
 	return typeParams === void 0 || Object.keys(typeParams).length > 0 ? descriptor : rest;
@@ -1315,19 +1328,19 @@ function coveredFieldNames(index) {
 	return expression.fields.map((ref) => ref.fieldName);
 }
 /**
-* The generators a field's `.onCreate(...)` and `.onUpdate(...)` calls resolve to for its column, merged over the phases a field preset or `field.generated(...)` sets.
+* The generators a field's `.onCreate(...)` and `.onUpdate(...)` calls resolve to for its column.
 */
 function resolveGeneratorCalls(input) {
 	const { modelName, fieldName, fieldState, descriptor, generatorFunctions } = input;
 	const calls = fieldState.generatorCalls;
-	if (calls === void 0) return fieldState.executionDefaults;
+	if (calls === void 0) return void 0;
 	const typeParams = descriptor.typeParams;
 	const column = {
 		codecId: descriptor.codecId,
 		typeParams,
 		length: input.columnLength(descriptor.codecId, typeParams)
 	};
-	const phases = { ...fieldState.executionDefaults };
+	const phases = {};
 	for (const phase of ["onCreate", "onUpdate"]) {
 		const call = calls[phase];
 		if (call === void 0) continue;
@@ -1852,4 +1865,4 @@ function autoincrement() {
 //#endregion
 export { check as a, enumType as c, member as d, model as f, buildContractDefinition as i, extensionModel as l, rel as m, bindEnumType as n, createComposedAuthoringHelpers as o, now as p, buildBoundContract as r, defineContract as s, autoincrement as t, field as u };
 
-//# sourceMappingURL=contract-builder-50lF0kz1.mjs.map
+//# sourceMappingURL=contract-builder-DMNe_jX9.mjs.map