@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/psl-build-RelubU2E.d.mts

@@ -0,0 +1,112 @@
+import { u as SqlColumnIR } from "./types-CuCxAQat-Dz8P4xyt.mjs";
+import "./types-ljUNyiWe.mjs";
+import { i as SqlDataType, l as SqlTypeParams } from "./data-type-DJIvKQHf.mjs";
+import "./default-mapping-CAOONlKQ-4m07nb-O.mjs";
+import { AuthoringTypeConstructorCall, AuthoringTypeConstructorDescriptor, AuthoringTypeNamespace, DataTypeSupport } from "@prisma/orm-framework/components/authoring";
+import { CodecLookupWithDescriptors, DataTypeLookup } from "@prisma/orm-framework/components/codec";
+import { ExecutionMutationDefaultPhases, ExecutionMutationDefaultValue } from "@prisma/orm-framework/contract/types";
+import { GeneratorFunctionField, GeneratorFunctionRegistry, GeneratorPhase } from "@prisma/orm-framework/components/components";
+//#region ../../../2-sql-family/9-family/dist/psl-build.d.mts
+//#region src/core/psl-build/inferred-type-constructors.d.ts
+/** The type constructor `contract infer` writes for a data type, with the data type it produces. */
+interface InferredTypeConstructor {
+  readonly path: readonly string[];
+  readonly descriptor: AuthoringTypeConstructorDescriptor;
+  readonly dataType: SqlDataType;
+}
+/** The constructors marked `inferred` in a stack, keyed by the id of the data type each produces. */
+type InferredTypeConstructors = ReadonlyMap<string, InferredTypeConstructor>;
+/** Every constructor of `authoringTypes` marked `inferred`, by the data type its codec represents. */
+declare function inferredTypeConstructors(input: {
+  readonly authoringTypes: AuthoringTypeNamespace;
+  readonly codecLookup: Pick<CodecLookupWithDescriptors, 'descriptorFor'>;
+  readonly dataTypeLookup: DataTypeLookup;
+}): InferredTypeConstructors;
+/**
+ * The call to `marked` with the fewest arguments that produces `params`, the normal form of a
+ * column's data type parameters: arguments are dropped from the end while the normal form of what
+ * the call produces stays `params`. Undefined when the constructor cannot produce them, such as one
+ * whose argument names another entity.
+ */
+declare function fewestArgumentsCall(marked: InferredTypeConstructor, params: SqlTypeParams): AuthoringTypeConstructorCall | undefined;
+/**
+ * Each argument of a call to `descriptor` as PSL writes it: a value argument as a literal of its data type that reads back as the same value. `undefined` when an argument is not a value argument or no literal reads back as it.
+ */
+declare function writtenTypeArguments(descriptor: AuthoringTypeConstructorDescriptor, args: readonly unknown[], dataTypes: DataTypeSupport): readonly string[] | undefined;
+//#endregion
+//#region src/core/psl-build/column-types.d.ts
+/** A call to a type constructor as PSL writes it: the constructor's path, its arguments' text, and the value each argument gives the constructor. */
+interface PslTypeCall {
+  readonly path: readonly string[];
+  readonly args: readonly string[];
+  readonly values: readonly unknown[];
+}
+/** The PSL type `contract infer` writes for a column that is not an enum, by table and column name. */
+type ColumnTypeOf = (tableName: string, columnName: string) => PslTypeCall;
+/** One introspected table, with the schema it was read from. */
+interface IntrospectedTable {
+  readonly schemaName: string;
+  readonly tableName: string;
+  readonly columns: readonly SqlColumnIR[];
+}
+/**
+ * The type of every column of `tables` that `isEnumColumn` does not claim: the call, with the
+ * fewest arguments, to the constructor marked `inferred` for the data type that claims the
+ * column's reported type. When any column has no such call, throws
+ * `CONTRACT.INFER_COLUMN_TYPE_UNCLAIMED` listing every one of them.
+ */
+declare function inferColumnTypes(input: {
+  readonly tables: readonly IntrospectedTable[];
+  readonly constructors: InferredTypeConstructors;
+  /** The stack's data types, whose literals write each argument. */
+  readonly dataTypes: DataTypeSupport;
+  readonly isEnumColumn: (column: SqlColumnIR) => boolean;
+}): ColumnTypeOf;
+//#endregion
+//#region src/core/psl-build/generator-calls.d.ts
+/** The call text that writes one phase of a column's generators. */
+interface PhaseCallText {
+  readonly phase: GeneratorPhase;
+  readonly text: string;
+}
+type GeneratorCallRefusal = {
+  readonly kind: 'on-list' | 'no-function';
+  readonly phase: GeneratorPhase;
+  readonly generator: ExecutionMutationDefaultValue;
+} | {
+  readonly kind: 'reads-back-differently';
+  readonly phase: GeneratorPhase;
+  readonly generator: ExecutionMutationDefaultValue;
+  readonly text: string;
+  readonly readBack: ExecutionMutationDefaultValue | undefined;
+  /** Why the call's binding refuses the column, when it does. */
+  readonly refusedBecause: string | undefined;
+};
+type GeneratorCallsResult = {
+  readonly ok: true;
+  readonly calls: readonly PhaseCallText[];
+} | {
+  readonly ok: false;
+  readonly refusal: GeneratorCallRefusal;
+};
+/**
+ * The generator function call that writes each phase of a column's generators, as `@onCreate(...)` and `@onUpdate(...)` take it. A call must resolve back to the stored generator, so a list column, a generator no function writes for the codec, and a call that reads back differently are refused.
+ */
+declare function generatorCallsFor(input: {
+  readonly executionDefault: ExecutionMutationDefaultPhases;
+  readonly field: GeneratorFunctionField;
+  readonly list: boolean;
+  readonly generatorFunctions: GeneratorFunctionRegistry;
+}): GeneratorCallsResult;
+//#endregion
+//#region src/core/psl-build/psl-names.d.ts
+/**
+ * PSL member name for a native-enum value. The value itself always prints
+ * explicitly (`member = "value"`), so the returned name never needs a map:
+ * a value that already is a valid, non-reserved identifier is kept verbatim
+ * (case included); anything else is camelCased/escaped like a field name.
+ */
+declare function toEnumMemberName(value: string): string;
+//#endregion
+export { InferredTypeConstructors as a, PslTypeCall as c, inferColumnTypes as d, inferredTypeConstructors as f, InferredTypeConstructor as i, fewestArgumentsCall as l, writtenTypeArguments as m, GeneratorCallRefusal as n, IntrospectedTable as o, toEnumMemberName as p, GeneratorCallsResult as r, PhaseCallText as s, ColumnTypeOf as t, generatorCallsFor as u };
+//# sourceMappingURL=psl-build-RelubU2E.d.mts.map

package/dist/psl-build-RelubU2E.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-build-RelubU2E.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/psl-build.d.mts"],"mappings":";;;;;;;;;;;UASU;WACC;WACA,YAAY;WACZ,UAAU;;;KAGhB,2BAA2B,oBAAoB;;iBAEnC,yBAAyB;WAC/B,gBAAgB;WAChB,aAAa,KAAK;WAClB,gBAAgB;IACvB;;;;;;;iBAOa,oBAAoB,QAAQ,yBAAyB,QAAQ,gBAAgB;;;;iBAI7E,qBAAqB,YAAY,oCAAoC,0BAA0B,WAAW;;;;UAIjH;WACC;WACA;WACA;;;KAGN,gBAAgB,mBAAmB,uBAAuB;;UAErD;WACC;WACA;WACA,kBAAkB;;;;;;;;iBAQZ,iBAAiB;WACvB,iBAAiB;WACjB,cAAc;;WAEd,WAAW;WACX,eAAe,QAAQ;IAC9B;;;;UAIM;WACC,OAAO;WACP;;KAEN;WACM;WACA,OAAO;WACP,WAAW;;WAEX;WACA,OAAO;WACP,WAAW;WACX;WACA,UAAU;;WAEV;;KAEN;WACM;WACA,gBAAgB;;WAEhB;WACA,SAAS;;;;;iBAKH,kBAAkB;WACxB,kBAAkB;WAClB,OAAO;WACP;WACA,oBAAoB;IAC3B;;;;;;;;;iBASa,iBAAiB"}

package/dist/psl-column-resolution-ChZqioOc-BREg4J7d.d.mts

@@ -0,0 +1,24 @@
+import "./contract-builder-C_Zi57iD.mjs";
+import { AuthoringTypeConstructorDescriptor, DataTypeSupport } from "@prisma/orm-framework/components/authoring";
+import { CodecLookupWithDescriptors } from "@prisma/orm-framework/components/codec";
+import { ColumnDefault, ExecutionMutationDefaultPhases, ValueSetRef } from "@prisma/orm-framework/contract/types";
+import "@prisma/orm-framework/components/control";
+import { Binder } from "@prisma/orm-framework/psl-parser";
+//#region ../../../2-sql-family/2-authoring/contract-psl/dist/psl-column-resolution-ChZqioOc.d.mts
+//#region src/psl-column-resolution.d.ts
+type ColumnDescriptor = {
+  readonly codecId: string;
+  readonly typeParams?: Record<string, unknown> | undefined;
+  /**
+   * Storage-plane value-set ref, set only by an entity-ref type constructor
+   * (e.g. `pg.enum(Ref)`) resolving `Ref` against a document-local
+   * value-set-deriving entity. Threaded straight onto the `StorageColumn` —
+   * the emitter types such a column by its value set (`ColumnTypeOverrides`
+   * in the emitted `contract.d.ts`); every other resolution path leaves it
+   * unset.
+   */
+  readonly valueSet?: ValueSetRef;
+};
+//#endregion
+export { ColumnDescriptor as t };
+//# sourceMappingURL=psl-column-resolution-ChZqioOc-BREg4J7d.d.mts.map

package/dist/psl-column-resolution-ChZqioOc-BREg4J7d.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-column-resolution-ChZqioOc-BREg4J7d.d.mts","names":[],"sources":["../../../../2-sql-family/2-authoring/contract-psl/dist/psl-column-resolution-ChZqioOc.d.mts"],"mappings":";;;;;;;;KASK;WACM;WACA,aAAa;;;;;;;;;WASb,WAAW"}