@prisma-next/sql-contract-ts 0.3.0-dev.135 → 0.3.0-dev.146

package/src/{staged-contract-types.ts → contract-types.ts}

@@ -1,19 +1,19 @@
-import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/contract/framework-components';
-import type { ColumnDefault } from '@prisma-next/contract/types';
+import type {
+  ColumnDefault,
+  Contract,
+  ContractRelation,
+  StorageHashBase,
+} from '@prisma-next/contract/types';
+import type { ExtensionPackRef, TargetPackRef } from '@prisma-next/framework-components/components';
 import type {
   ContractWithTypeMaps,
   Index,
   ReferentialAction,
-  SqlContract,
   StorageTypeInstance,
   TypeMaps,
 } from '@prisma-next/sql-contract/types';
 import type { UnionToIntersection } from './authoring-type-utils';
-import type {
-  AttributeStageIdFieldNames,
-  FieldStateOf,
-  ScalarFieldBuilder,
-} from './staged-contract-dsl';
+import type { AttributeStageIdFieldNames, FieldStateOf, ScalarFieldBuilder } from './contract-dsl';
 
 export type ExtractCodecTypesFromPack<P> = P extends { __codecTypes?: infer C }
   ? C extends Record<string, { output: unknown }>
@@ -39,38 +39,32 @@ export type MergeExtensionPackRefs<
   Added extends Record<string, ExtensionPackRef<'sql', string>>,
 > = Existing extends Record<string, unknown> ? Existing & Added : Added;
 
-type StagedDefinitionExtensionPacks<Definition> = Definition extends {
+type DefinitionExtensionPacks<Definition> = Definition extends {
   readonly extensionPacks?: infer Packs extends Record<string, ExtensionPackRef<'sql', string>>;
 }
   ? Packs
   : Record<never, never>;
 
-type StagedDefinitionCapabilities<Definition> = Definition extends {
+type DefinitionCapabilities<Definition> = Definition extends {
   readonly capabilities?: infer Capabilities extends Record<string, Record<string, boolean>>;
 }
   ? Capabilities
   : undefined;
 
-type StagedDefinitionTargetId<Definition> = Definition extends {
+type DefinitionTargetId<Definition> = Definition extends {
   readonly target: TargetPackRef<'sql', infer Target>;
 }
   ? Target
   : never;
 
-type StagedDefinitionStorageHash<Definition> = Definition extends {
-  readonly storageHash?: infer StorageHash extends string;
-}
-  ? StorageHash
-  : undefined;
-
 type Present<T> = Exclude<T, undefined>;
 
-type CodecTypesFromStagedDefinition<Definition> = ExtractCodecTypesFromPack<
+type CodecTypesFromDefinition<Definition> = ExtractCodecTypesFromPack<
   Definition extends { readonly target: infer Target } ? Target : never
 > &
-  MergeExtensionCodecTypesSafe<StagedDefinitionExtensionPacks<Definition>>;
+  MergeExtensionCodecTypesSafe<DefinitionExtensionPacks<Definition>>;
 
-type StagedDefinitionModels<Definition> = Definition extends {
+type DefinitionModels<Definition> = Definition extends {
   readonly models?: unknown;
 }
   ? Present<Definition['models']> extends Record<string, unknown>
@@ -78,7 +72,7 @@ type StagedDefinitionModels<Definition> = Definition extends {
     : Record<never, never>
   : Record<never, never>;
 
-type StagedDefinitionTypes<Definition> = Definition extends {
+type DefinitionTypes<Definition> = Definition extends {
   readonly types?: unknown;
 }
   ? Present<Definition['types']> extends Record<string, StorageTypeInstance>
@@ -86,13 +80,13 @@ type StagedDefinitionTypes<Definition> = Definition extends {
     : Record<never, never>
   : Record<never, never>;
 
-type StagedDefinitionTableNaming<Definition> = Definition extends {
+type DefinitionTableNaming<Definition> = Definition extends {
   readonly naming?: { readonly tables?: infer Strategy extends string };
 }
   ? Strategy
   : undefined;
 
-type StagedDefinitionColumnNaming<Definition> = Definition extends {
+type DefinitionColumnNaming<Definition> = Definition extends {
   readonly naming?: { readonly columns?: infer Strategy extends string };
 }
   ? Strategy
@@ -139,43 +133,60 @@ type ApplyNamingType<Name extends string, Strategy extends string | undefined> =
     ? SnakeCase<Name>
     : Name;
 
-type StagedModelNames<Definition> = keyof StagedDefinitionModels<Definition> & string;
+type ModelNames<Definition> = keyof DefinitionModels<Definition> & string;
 
-type StagedModelFields<
+type ModelFields<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = StagedDefinitionModels<Definition>[ModelName] extends {
+  ModelName extends ModelNames<Definition>,
+> = DefinitionModels<Definition>[ModelName] extends {
   readonly stageOne: {
     readonly fields: Record<string, ScalarFieldBuilder>;
   };
 }
-  ? StagedDefinitionModels<Definition>[ModelName]['stageOne']['fields']
+  ? DefinitionModels<Definition>[ModelName]['stageOne']['fields']
+  : Record<never, never>;
+
+type ModelFieldNames<Definition, ModelName extends ModelNames<Definition>> = keyof ModelFields<
+  Definition,
+  ModelName
+> &
+  string;
+
+type StagedModelRelations<
+  Definition,
+  ModelName extends ModelNames<Definition>,
+> = DefinitionModels<Definition>[ModelName] extends {
+  readonly stageOne: { readonly relations: infer R };
+}
+  ? R extends Record<string, unknown>
+    ? R
+    : Record<never, never>
   : Record<never, never>;
 
-type StagedModelFieldNames<
+type StagedModelRelationNames<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = keyof StagedModelFields<Definition, ModelName> & string;
+  ModelName extends ModelNames<Definition>,
+> = keyof StagedModelRelations<Definition, ModelName> & string;
 
-type StagedModelFieldState<
+type ModelFieldState<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-  FieldName extends StagedModelFieldNames<Definition, ModelName>,
-> = FieldStateOf<StagedModelFields<Definition, ModelName>[FieldName]>;
+  ModelName extends ModelNames<Definition>,
+  FieldName extends ModelFieldNames<Definition, ModelName>,
+> = FieldStateOf<ModelFields<Definition, ModelName>[FieldName]>;
 
-type StagedModelSql<
+type ModelSql<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = StagedDefinitionModels<Definition>[ModelName] extends {
+  ModelName extends ModelNames<Definition>,
+> = DefinitionModels<Definition>[ModelName] extends {
   readonly __sql: infer SqlSpec;
 }
   ? SqlSpec
   : undefined;
 
-type StagedModelAttributes<
+type ModelAttributes<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = StagedDefinitionModels<Definition>[ModelName] extends {
+  ModelName extends ModelNames<Definition>,
+> = DefinitionModels<Definition>[ModelName] extends {
   readonly __attributes: infer AttributesSpec;
 }
   ? AttributesSpec
@@ -228,14 +239,14 @@ type DescriptorTypeRef<Descriptor> = Descriptor extends {
   : undefined;
 
 type LookupNamedStorageTypeKeyByValue<Definition, TypeRef extends StorageTypeInstance> = {
-  [TypeName in keyof StagedDefinitionTypes<Definition> & string]: [TypeRef] extends [
-    StagedDefinitionTypes<Definition>[TypeName],
+  [TypeName in keyof DefinitionTypes<Definition> & string]: [TypeRef] extends [
+    DefinitionTypes<Definition>[TypeName],
   ]
-    ? [StagedDefinitionTypes<Definition>[TypeName]] extends [TypeRef]
+    ? [DefinitionTypes<Definition>[TypeName]] extends [TypeRef]
       ? TypeName
       : never
     : never;
-}[keyof StagedDefinitionTypes<Definition> & string];
+}[keyof DefinitionTypes<Definition> & string];
 
 type ResolveNamedStorageTypeKey<Definition, TypeRef> = TypeRef extends string
   ? TypeRef
@@ -247,8 +258,8 @@ type ResolveNamedStorageTypeKey<Definition, TypeRef> = TypeRef extends string
 
 type ResolveNamedStorageType<Definition, TypeRef> =
   ResolveNamedStorageTypeKey<Definition, TypeRef> extends infer TypeName extends string
-    ? TypeName extends keyof StagedDefinitionTypes<Definition>
-      ? StagedDefinitionTypes<Definition>[TypeName]
+    ? TypeName extends keyof DefinitionTypes<Definition>
+      ? DefinitionTypes<Definition>[TypeName]
       : StorageTypeInstance
     : StorageTypeInstance;
 
@@ -270,98 +281,96 @@ type ResolveFieldColumnTypeParams<Definition, FieldState> = [
   ? undefined
   : DescriptorTypeParams<FieldDescriptorOf<FieldState>>;
 
-type StagedModelTableName<Definition, ModelName extends StagedModelNames<Definition>> = [
+type ModelTableName<Definition, ModelName extends ModelNames<Definition>> = [
   Present<
-    StagedModelSql<Definition, ModelName> extends { readonly table?: infer TableName }
-      ? TableName
-      : never
+    ModelSql<Definition, ModelName> extends { readonly table?: infer TableName } ? TableName : never
   >,
 ] extends [never]
-  ? ApplyNamingType<ModelName, StagedDefinitionTableNaming<Definition>>
+  ? ApplyNamingType<ModelName, DefinitionTableNaming<Definition>>
   : Present<
-        StagedModelSql<Definition, ModelName> extends { readonly table?: infer TableName }
+        ModelSql<Definition, ModelName> extends { readonly table?: infer TableName }
           ? TableName
           : never
       > extends infer ExplicitTableName extends string
     ? ExplicitTableName
-    : ApplyNamingType<ModelName, StagedDefinitionTableNaming<Definition>>;
+    : ApplyNamingType<ModelName, DefinitionTableNaming<Definition>>;
 
-type StagedModelColumnName<
+type ModelColumnName<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-  FieldName extends StagedModelFieldNames<Definition, ModelName>,
-> = [FieldColumnOverrideOf<StagedModelFieldState<Definition, ModelName, FieldName>>] extends [never]
-  ? ApplyNamingType<FieldName, StagedDefinitionColumnNaming<Definition>>
+  ModelName extends ModelNames<Definition>,
+  FieldName extends ModelFieldNames<Definition, ModelName>,
+> = [FieldColumnOverrideOf<ModelFieldState<Definition, ModelName, FieldName>>] extends [never]
+  ? ApplyNamingType<FieldName, DefinitionColumnNaming<Definition>>
   : FieldColumnOverrideOf<
-        StagedModelFieldState<Definition, ModelName, FieldName>
+        ModelFieldState<Definition, ModelName, FieldName>
       > extends infer ExplicitColumnName extends string
     ? ExplicitColumnName
-    : ApplyNamingType<FieldName, StagedDefinitionColumnNaming<Definition>>;
+    : ApplyNamingType<FieldName, DefinitionColumnNaming<Definition>>;
 
-type StagedFieldNamesToColumnNames<
+type FieldNamesToColumnNames<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
+  ModelName extends ModelNames<Definition>,
   FieldNames extends readonly string[],
 > = FieldNames extends readonly []
   ? readonly []
   : FieldNames extends readonly [
-        infer First extends StagedModelFieldNames<Definition, ModelName>,
+        infer First extends ModelFieldNames<Definition, ModelName>,
         ...infer Rest extends readonly string[],
       ]
     ? readonly [
-        StagedModelColumnName<Definition, ModelName, First>,
-        ...StagedFieldNamesToColumnNames<Definition, ModelName, Rest>,
+        ModelColumnName<Definition, ModelName, First>,
+        ...FieldNamesToColumnNames<Definition, ModelName, Rest>,
       ]
     : readonly string[];
 
-type StagedInlineIdFieldName<Definition, ModelName extends StagedModelNames<Definition>> = {
-  [FieldName in StagedModelFieldNames<Definition, ModelName>]: [
-    FieldInlineIdSpecOf<StagedModelFieldState<Definition, ModelName, FieldName>>,
+type InlineIdFieldName<Definition, ModelName extends ModelNames<Definition>> = {
+  [FieldName in ModelFieldNames<Definition, ModelName>]: [
+    FieldInlineIdSpecOf<ModelFieldState<Definition, ModelName, FieldName>>,
   ] extends [never]
     ? never
     : FieldName;
-}[StagedModelFieldNames<Definition, ModelName>];
+}[ModelFieldNames<Definition, ModelName>];
 
-type StagedInlineIdFieldNames<Definition, ModelName extends StagedModelNames<Definition>> = [
-  StagedInlineIdFieldName<Definition, ModelName>,
+type InlineIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = [
+  InlineIdFieldName<Definition, ModelName>,
 ] extends [never]
   ? undefined
-  : readonly [StagedInlineIdFieldName<Definition, ModelName>];
+  : readonly [InlineIdFieldName<Definition, ModelName>];
 
-type StagedInlineIdName<Definition, ModelName extends StagedModelNames<Definition>> = {
-  [FieldName in StagedModelFieldNames<Definition, ModelName>]: FieldInlineIdSpecOf<
-    StagedModelFieldState<Definition, ModelName, FieldName>
+type InlineIdName<Definition, ModelName extends ModelNames<Definition>> = {
+  [FieldName in ModelFieldNames<Definition, ModelName>]: FieldInlineIdSpecOf<
+    ModelFieldState<Definition, ModelName, FieldName>
   > extends { readonly name?: infer Name extends string }
     ? Name
     : never;
-}[StagedModelFieldNames<Definition, ModelName>];
+}[ModelFieldNames<Definition, ModelName>];
 
-type StagedAttributeIdFieldNames<
+type AttributeIdFieldNames<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = AttributeStageIdFieldNames<StagedModelAttributes<Definition, ModelName>>;
+  ModelName extends ModelNames<Definition>,
+> = AttributeStageIdFieldNames<ModelAttributes<Definition, ModelName>>;
 
-type StagedAttributeIdName<Definition, ModelName extends StagedModelNames<Definition>> = Present<
-  StagedModelAttributes<Definition, ModelName> extends {
+type AttributeIdName<Definition, ModelName extends ModelNames<Definition>> = Present<
+  ModelAttributes<Definition, ModelName> extends {
     readonly id?: { readonly name?: infer Name extends string };
   }
     ? Name
     : never
 >;
 
-type StagedModelIdFieldNames<Definition, ModelName extends StagedModelNames<Definition>> = [
-  StagedAttributeIdFieldNames<Definition, ModelName>,
+type ModelIdFieldNames<Definition, ModelName extends ModelNames<Definition>> = [
+  AttributeIdFieldNames<Definition, ModelName>,
 ] extends [undefined]
-  ? StagedInlineIdFieldNames<Definition, ModelName>
-  : StagedAttributeIdFieldNames<Definition, ModelName>;
+  ? InlineIdFieldNames<Definition, ModelName>
+  : AttributeIdFieldNames<Definition, ModelName>;
 
-type StagedModelIdName<Definition, ModelName extends StagedModelNames<Definition>> = [
-  StagedAttributeIdName<Definition, ModelName>,
+type ModelIdName<Definition, ModelName extends ModelNames<Definition>> = [
+  AttributeIdName<Definition, ModelName>,
 ] extends [never]
-  ? Present<StagedInlineIdName<Definition, ModelName>>
-  : StagedAttributeIdName<Definition, ModelName>;
+  ? Present<InlineIdName<Definition, ModelName>>
+  : AttributeIdName<Definition, ModelName>;
 
-type StagedStorageColumn<
+type StorageColumn<
   CodecId extends string,
   Nullable extends boolean,
   NativeType extends string,
@@ -377,67 +386,70 @@ type StagedStorageColumn<
     ? { readonly typeParams: TypeParams }
     : Record<string, never>);
 
-type StagedModelStorageColumn<
+type ModelStorageColumn<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
+  ModelName extends ModelNames<Definition>,
   FieldName extends string,
-> = FieldName extends StagedModelFieldNames<Definition, ModelName>
-  ? StagedStorageColumn<
+> = FieldName extends ModelFieldNames<Definition, ModelName>
+  ? StorageColumn<
       DescriptorCodecId<
-        ResolveFieldDescriptor<Definition, StagedModelFieldState<Definition, ModelName, FieldName>>
+        ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>
       >,
-      FieldNullableOf<StagedModelFieldState<Definition, ModelName, FieldName>>,
+      FieldNullableOf<ModelFieldState<Definition, ModelName, FieldName>>,
       DescriptorNativeType<
-        ResolveFieldDescriptor<Definition, StagedModelFieldState<Definition, ModelName, FieldName>>
-      >,
-      ResolveFieldColumnTypeRef<
-        Definition,
-        StagedModelFieldState<Definition, ModelName, FieldName>
+        ResolveFieldDescriptor<Definition, ModelFieldState<Definition, ModelName, FieldName>>
       >,
-      ResolveFieldColumnTypeParams<
-        Definition,
-        StagedModelFieldState<Definition, ModelName, FieldName>
-      >
+      ResolveFieldColumnTypeRef<Definition, ModelFieldState<Definition, ModelName, FieldName>>,
+      ResolveFieldColumnTypeParams<Definition, ModelFieldState<Definition, ModelName, FieldName>>
     >
   : never;
 
-type StagedBuiltModels<Definition> = {
-  readonly [ModelName in StagedModelNames<Definition>]: {
+type BuiltModels<Definition> = {
+  readonly [ModelName in ModelNames<Definition>]: {
     readonly storage: {
-      readonly table: StagedModelTableName<Definition, ModelName>;
+      readonly table: ModelTableName<Definition, ModelName>;
+      readonly fields: {
+        readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
+          readonly column: ModelColumnName<Definition, ModelName, FieldName>;
+        };
+      };
     };
     readonly fields: {
-      readonly [FieldName in StagedModelFieldNames<Definition, ModelName>]: {
-        readonly column: StagedModelColumnName<Definition, ModelName, FieldName>;
+      readonly [FieldName in ModelFieldNames<Definition, ModelName>]: {
+        readonly nullable: ModelStorageColumn<Definition, ModelName, FieldName>['nullable'];
+        readonly type: {
+          readonly kind: 'scalar';
+          readonly codecId: ModelStorageColumn<Definition, ModelName, FieldName>['codecId'];
+        };
       };
     };
+    readonly relations: {
+      readonly [RelName in StagedModelRelationNames<Definition, ModelName>]: ContractRelation;
+    };
   };
 };
 
-type StagedBuiltModelFields<
+type BuiltModelColumnMappings<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = StagedBuiltModels<Definition>[ModelName]['fields'];
+  ModelName extends ModelNames<Definition>,
+> = BuiltModels<Definition>[ModelName]['storage']['fields'];
 
-type StagedBuiltModelTableName<
+type BuiltModelTableName<
   Definition,
-  ModelName extends StagedModelNames<Definition>,
-> = StagedBuiltModels<Definition>[ModelName]['storage']['table'];
+  ModelName extends ModelNames<Definition>,
+> = BuiltModels<Definition>[ModelName]['storage']['table'];
 
-type StagedBuiltStorageTableColumns<Definition, ModelName extends StagedModelNames<Definition>> = {
-  readonly [FieldName in keyof StagedBuiltModelFields<Definition, ModelName> &
-    string as StagedBuiltModelFields<
+type BuiltStorageTableColumns<Definition, ModelName extends ModelNames<Definition>> = {
+  readonly [FieldName in keyof BuiltModelColumnMappings<Definition, ModelName> &
+    string as BuiltModelColumnMappings<
     Definition,
     ModelName
-  >[FieldName]['column']]: StagedModelStorageColumn<Definition, ModelName, FieldName>;
+  >[FieldName]['column']]: ModelStorageColumn<Definition, ModelName, FieldName>;
 };
 
-type StagedBuiltStorageTables<Definition> = {
-  readonly [ModelName in StagedModelNames<Definition> as StagedBuiltModelTableName<
-    Definition,
-    ModelName
-  >]: {
-    readonly columns: StagedBuiltStorageTableColumns<Definition, ModelName>;
+type BuiltStorageTables<Definition> = {
+  readonly [ModelName in ModelNames<Definition> as BuiltModelTableName<Definition, ModelName>]: {
+    readonly columns: BuiltStorageTableColumns<Definition, ModelName>;
     readonly uniques: ReadonlyArray<{
       readonly columns: readonly string[];
       readonly name?: string;
@@ -452,43 +464,71 @@ type StagedBuiltStorageTables<Definition> = {
       readonly constraint: boolean;
       readonly index: boolean;
     }>;
-  } & (StagedModelIdFieldNames<Definition, ModelName> extends readonly string[]
+  } & (ModelIdFieldNames<Definition, ModelName> extends readonly string[]
     ? {
         readonly primaryKey: {
-          readonly columns: StagedFieldNamesToColumnNames<
+          readonly columns: FieldNamesToColumnNames<
             Definition,
             ModelName,
-            StagedModelIdFieldNames<Definition, ModelName>
+            ModelIdFieldNames<Definition, ModelName>
           >;
-          readonly name?: StagedModelIdName<Definition, ModelName>;
+          readonly name?: ModelIdName<Definition, ModelName>;
         };
       }
     : Record<string, never>);
 };
 
-type StagedBuiltStorage<Definition> = {
-  readonly tables: StagedBuiltStorageTables<Definition>;
-  readonly types: StagedDefinitionTypes<Definition>;
+type BuiltStorage<Definition> = {
+  readonly storageHash: StorageHashBase<string>;
+  readonly tables: BuiltStorageTables<Definition>;
+  readonly types: DefinitionTypes<Definition>;
+};
+
+type FieldOutputType<
+  Definition,
+  ModelName extends ModelNames<Definition>,
+  FieldName extends ModelFieldNames<Definition, ModelName>,
+> = ModelStorageColumn<Definition, ModelName, FieldName> extends infer Col
+  ? Col extends { readonly codecId: infer Id extends string }
+    ? Id extends keyof CodecTypesFromDefinition<Definition>
+      ? CodecTypesFromDefinition<Definition>[Id] extends { readonly output: infer O }
+        ? Col extends { readonly nullable: true }
+          ? O | null
+          : O
+        : unknown
+      : unknown
+    : unknown
+  : unknown;
+
+type FieldOutputTypes<Definition> = {
+  readonly [ModelName in ModelNames<Definition>]: {
+    readonly [FieldName in ModelFieldNames<Definition, ModelName>]: FieldOutputType<
+      Definition,
+      ModelName,
+      FieldName
+    >;
+  };
 };
 
 export type SqlContractResult<Definition> = ContractWithTypeMaps<
-  SqlContract<StagedBuiltStorage<Definition>, StagedBuiltModels<Definition>> & {
-    readonly schemaVersion: '1';
-    readonly target: StagedDefinitionTargetId<Definition>;
+  Contract<BuiltStorage<Definition>, BuiltModels<Definition>> & {
+    readonly target: DefinitionTargetId<Definition>;
     readonly targetFamily: 'sql';
-    readonly storageHash: StagedDefinitionStorageHash<Definition> extends string
-      ? StagedDefinitionStorageHash<Definition>
-      : string;
   } & {
-    readonly extensionPacks: keyof StagedDefinitionExtensionPacks<Definition> extends never
+    readonly extensionPacks: keyof DefinitionExtensionPacks<Definition> extends never
       ? Record<string, never>
-      : StagedDefinitionExtensionPacks<Definition>;
-    readonly capabilities: StagedDefinitionCapabilities<Definition> extends Record<
+      : DefinitionExtensionPacks<Definition>;
+    readonly capabilities: DefinitionCapabilities<Definition> extends Record<
       string,
       Record<string, boolean>
     >
-      ? StagedDefinitionCapabilities<Definition>
+      ? DefinitionCapabilities<Definition>
       : Record<string, Record<string, boolean>>;
   },
-  TypeMaps<CodecTypesFromStagedDefinition<Definition>, Record<string, never>>
+  TypeMaps<
+    CodecTypesFromDefinition<Definition>,
+    Record<string, never>,
+    Record<string, never>,
+    FieldOutputTypes<Definition>
+  >
 >;

package/src/{staged-contract-warnings.ts → contract-warnings.ts}

@@ -1,18 +1,18 @@
 import type { StorageTypeInstance } from '@prisma-next/sql-contract/types';
 import {
+  type ContractModelBuilder,
   type ModelAttributesSpec,
   normalizeRelationFieldNames,
   type RelationBuilder,
+  type RelationState,
   type ScalarFieldBuilder,
   type SqlStageSpec,
-  type StagedModelBuilder,
-  type RelationState as StagedRelationState,
-} from './staged-contract-dsl';
+} from './contract-dsl';
 
-type RuntimeStagedModel = StagedModelBuilder<
+type RuntimeModel = ContractModelBuilder<
   string | undefined,
   Record<string, ScalarFieldBuilder>,
-  Record<string, RelationBuilder<StagedRelationState>>,
+  Record<string, RelationBuilder<RelationState>>,
   ModelAttributesSpec | undefined,
   SqlStageSpec | undefined
 >;
@@ -20,20 +20,17 @@ type RuntimeStagedModel = StagedModelBuilder<
 type RuntimeModelSpec = {
   readonly modelName: string;
   readonly tableName: string;
-  readonly relations: Record<string, RelationBuilder<StagedRelationState>>;
+  readonly relations: Record<string, RelationBuilder<RelationState>>;
   readonly sqlSpec: SqlStageSpec | undefined;
 };
 
-type RuntimeStagedCollection = {
+type RuntimeCollection = {
   readonly storageTypes: Record<string, StorageTypeInstance>;
-  readonly models: Record<string, RuntimeStagedModel>;
+  readonly models: Record<string, RuntimeModel>;
   readonly modelSpecs: ReadonlyMap<string, RuntimeModelSpec>;
 };
 
-function hasNamedModelToken(
-  models: Record<string, RuntimeStagedModel>,
-  modelName: string,
-): boolean {
+function hasNamedModelToken(models: Record<string, RuntimeModel>, modelName: string): boolean {
   return models[modelName]?.stageOne.modelName === modelName;
 }
 
@@ -65,8 +62,8 @@ function formatConstraintsRefCall(modelName: string, fieldNames: readonly string
 
 function formatRelationModelDisplay(
   relationModel:
-    | StagedRelationState['toModel']
-    | Extract<StagedRelationState, { kind: 'manyToMany' }>['through'],
+    | RelationState['toModel']
+    | Extract<RelationState, { kind: 'manyToMany' }>['through'],
 ): string {
   if (relationModel.kind === 'lazyRelationModelName') {
     return `() => ${relationModel.resolve()}`;
@@ -77,7 +74,7 @@ function formatRelationModelDisplay(
     : relationModel.modelName;
 }
 
-function formatRelationCall(relation: StagedRelationState, targetModelDisplay: string): string {
+function formatRelationCall(relation: RelationState, targetModelDisplay: string): string {
   if (relation.kind === 'belongsTo') {
     const from = formatFieldSelection(normalizeRelationFieldNames(relation.from));
     const to = formatFieldSelection(normalizeRelationFieldNames(relation.to));
@@ -96,7 +93,7 @@ function formatRelationCall(relation: StagedRelationState, targetModelDisplay: s
 }
 
 function formatManyToManyCallWithThrough(
-  relation: Extract<StagedRelationState, { kind: 'manyToMany' }>,
+  relation: Extract<RelationState, { kind: 'manyToMany' }>,
   throughDisplay: string,
 ): string {
   const targetDisplay = formatRelationModelDisplay(relation.toModel);
@@ -120,7 +117,7 @@ function flushWarnings(warnings: readonly string[]): void {
   }
 
   process.emitWarning(
-    `${warnings.length} staged contract references use string fallbacks where typed alternatives are available. ` +
+    `${warnings.length} contract references use string fallbacks where typed alternatives are available. ` +
       'Use named model tokens and typed storage type refs for autocomplete and type safety.\n' +
       warnings.map((w) => `  - ${w}`).join('\n'),
     { code: 'PN_CONTRACT_TYPED_FALLBACK_AVAILABLE' },
@@ -129,13 +126,13 @@ function flushWarnings(warnings: readonly string[]): void {
 
 function formatFallbackWarning(location: string, current: string, suggested: string): string {
   return (
-    `Staged contract ${location} uses ${current}. ` +
+    `Contract ${location} uses ${current}. ` +
     `Use ${suggested} when the named model token is available in the same contract to keep typed relation targets and model refs.`
   );
 }
 
 export function emitTypedNamedTypeFallbackWarnings(
-  models: Record<string, RuntimeStagedModel>,
+  models: Record<string, RuntimeModel>,
   storageTypes: Record<string, StorageTypeInstance>,
 ): void {
   const warnings: string[] = [];
@@ -155,7 +152,7 @@ export function emitTypedNamedTypeFallbackWarnings(
       warnedFields.add(warningKey);
 
       warnings.push(
-        `Staged contract field "${modelName}.${fieldName}" uses field.namedType('${fieldState.typeRef}'). ` +
+        `Contract field "${modelName}.${fieldName}" uses field.namedType('${fieldState.typeRef}'). ` +
           `Use field.namedType(types.${fieldState.typeRef}) when the storage type is declared in the same contract to keep autocomplete and typed local refs.`,
       );
     }
@@ -164,7 +161,7 @@ export function emitTypedNamedTypeFallbackWarnings(
   flushWarnings(warnings);
 }
 
-export function emitTypedCrossModelFallbackWarnings(collection: RuntimeStagedCollection): void {
+export function emitTypedCrossModelFallbackWarnings(collection: RuntimeCollection): void {
   const warnings: string[] = [];
   const warnedKeys = new Set<string>();