@aws-amplify/data-schema 1.9.2 → 1.10.0

package/dist/esm/EnumType.d.ts

@@ -3,6 +3,11 @@ type EnumTypeParamShape<values extends readonly string[] = readonly string[]> =
     type: 'enum';
     values: values;
 };
+/**
+ * Enum type definition content
+ *
+ * @param values - The values of the enum
+ */
 export interface EnumType<values extends readonly string[] = readonly string[]> extends EnumTypeParamShape<values> {
     [brandSymbol]: 'enum';
 }

package/dist/esm/MappedTypes/ModelMetadata.d.ts

@@ -1,7 +1,7 @@
 import { type UnionToIntersection, type ExcludeEmpty } from '@aws-amplify/data-schema-types';
 import type { PrimaryIndexIrShape } from '../util';
 import type { ModelType } from '../ModelType';
-import type { ModelRelationalFieldParamShape } from '../ModelRelationalField';
+import type { ModelRelationshipFieldParamShape } from '../ModelRelationshipField';
 export type ModelIdentifier<T> = {
     [Property in keyof T]: T[Property] extends ModelType<infer R, any> ? R['identifier'] extends PrimaryIndexIrShape ? {
         identifier: R['identifier'];
@@ -12,14 +12,14 @@ export type ModelSecondaryIndexes<T> = {
         secondaryIndexes: R['secondaryIndexes'];
     } : never : never;
 };
-export type RelationalMetadata<ResolvedSchema, ResolvedFields extends Record<string, unknown>, IdentifierMeta extends Record<string, {
+export type RelationshipMetadata<ResolvedSchema, ResolvedFields extends Record<string, unknown>, IdentifierMeta extends Record<string, {
     identifier: PrimaryIndexIrShape;
 }>> = UnionToIntersection<ExcludeEmpty<{
     [ModelName in keyof ResolvedSchema]: {
-        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasOne' | 'belongsTo' ? ModelName : never : never]: ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasMany' ? {
-            relationalInputFields: Partial<Record<`${Uncapitalize<ModelName & string>}`, NormalizeInputFields<ResolvedFields[ModelName & string], ExtractModelIdentifier<ModelName, IdentifierMeta>>>>;
+        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasOne' | 'belongsTo' ? ModelName : never : never]: ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape ? ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasMany' ? {
+            relationshipInputFields: Partial<Record<`${Uncapitalize<ModelName & string>}`, NormalizeInputFields<ResolvedFields[ModelName & string], ExtractModelIdentifier<ModelName, IdentifierMeta>>>>;
         } : {
-            relationalInputFields: Partial<Record<Field, NormalizeInputFields<ResolvedFields[ResolvedSchema[ModelName][Field]['relatedModel']], ExtractModelIdentifier<`${Capitalize<Field & string>}`, IdentifierMeta>>>>;
+            relationshipInputFields: Partial<Record<Field, NormalizeInputFields<ResolvedFields[ResolvedSchema[ModelName][Field]['relatedModel']], ExtractModelIdentifier<`${Capitalize<Field & string>}`, IdentifierMeta>>>>;
         } : never : never;
     };
 }[keyof ResolvedSchema]>>;

package/dist/esm/MappedTypes/ResolveFieldProperties.d.ts

@@ -3,7 +3,7 @@ import type { Authorization, ImpliedAuthFields } from '../Authorization';
 import type { ModelField } from '../ModelField';
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
-import type { ModelRelationalField, ModelRelationalFieldParamShape } from '../ModelRelationalField';
+import type { ModelRelationshipField, ModelRelationshipFieldParamShape } from '../ModelRelationshipField';
 import type { PrimaryIndexIrShape } from '../util/';
 import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
 import type { InjectImplicitModelFields } from './ImplicitFieldInjector';
@@ -15,11 +15,11 @@ import type { EnumType } from '../EnumType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 export type ResolveFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, {
     identifier: PrimaryIndexIrShape;
-}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema, IdentifierMeta>, FieldsWithRelationships = ResolveModelsRelationalAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>>;
-export type ResolveStaticFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema & ImplicitModelsSchema, never>, FieldsWithRelationships = ResolveModelsRelationalAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>>;
-type GetRelationshipRef<T, RM extends keyof T, TypeArg extends ModelRelationalFieldParamShape, Flat extends boolean, ResolvedModel = ResolveRelationalFieldsForModel<T, RM, Flat>, Model = TypeArg['valueRequired'] extends true ? ResolvedModel : ResolvedModel | null | undefined> = LazyLoader<Model, TypeArg['array']>;
-type ResolveRelationalFieldsForModel<Schema, ModelName extends keyof Schema, Flat extends boolean> = {
-    [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationalFieldParamShape ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelName][FieldName]['relatedModel'], Schema[ModelName][FieldName], Flat> : never : Schema[ModelName][FieldName];
+}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema, IdentifierMeta>, FieldsWithRelationships = ResolveModelsRelationshipAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>>;
+export type ResolveStaticFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema & ImplicitModelsSchema, never>, FieldsWithRelationships = ResolveModelsRelationshipAndRefFields<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>>;
+type GetRelationshipRef<T, RM extends keyof T, TypeArg extends ModelRelationshipFieldParamShape, Flat extends boolean, ResolvedModel = ResolveRelationshipFieldsForModel<T, RM, Flat>, Model = TypeArg['valueRequired'] extends true ? ResolvedModel : ResolvedModel | null | undefined> = LazyLoader<Model, TypeArg['array']>;
+type ResolveRelationshipFieldsForModel<Schema, ModelName extends keyof Schema, Flat extends boolean> = {
+    [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationshipFieldParamShape ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelName][FieldName]['relatedModel'], Schema[ModelName][FieldName], Flat> : never : Schema[ModelName][FieldName];
 };
 export type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], RefValue = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never, Value = Ref['valueRequired'] extends true ? RefValue : RefValue | null> = ResolveRefValueArrayTraits<Ref, Value>;
 /**
@@ -31,9 +31,9 @@ export type ResolveRefsOfCustomType<NonModelTypes extends NonModelTypesShape, T>
     [Prop in keyof T]: T[Prop] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : T[Prop];
 } extends infer Resolved ? ResolveFieldRequirements<Resolved> : never;
 export type ResolveFieldRequirements<Resolved> = Intersection<ExtractNullableFieldsToOptionalFields<Resolved>, ExtractNonNullableFieldsToRequiredFields<Resolved>>;
-type ResolveModelsRelationalAndRefFields<Schema, NonModelTypes extends NonModelTypesShape, Flat extends boolean = false> = {
+type ResolveModelsRelationshipAndRefFields<Schema, NonModelTypes extends NonModelTypesShape, Flat extends boolean = false> = {
     [ModelProp in keyof Schema]: {
-        [FieldProp in keyof Schema[ModelProp]]: Schema[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
+        [FieldProp in keyof Schema[ModelProp]]: Schema[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> | null ? ResolveRef<NonModelTypes, R> : Schema[ModelProp][FieldProp] extends ModelRelationshipFieldParamShape ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
     };
 };
 type FilterFieldTypes<Schema> = {
@@ -60,5 +60,5 @@ export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
     [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType ? never : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomOperation<CustomOperationParamShape, any> ? never : ModelKey]: Schema['data']['types'][ModelKey] extends ModelType<infer Model, any> ? AllAuthFieldsForModel<Schema, Model> : object;
 };
 type AllAuthFieldsForModel<Schema extends GenericModelSchema<any>, Model extends Schema['data']['types'][keyof Schema['data']['types']]> = (Model['authorization'][number] extends never ? Schema['data']['authorization'][number] extends never ? object : ImpliedAuthFields<Schema['data']['authorization'][number]> : ImpliedAuthFields<Model['authorization'][number]>) & ImpliedAuthFieldsFromFields<Model>;
-type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<T extends ModelTypeParamShape ? T['fields'][keyof T['fields']] extends ModelField<any, any, infer Auth> | ModelRelationalField<any, any, any, infer Auth> | RefType<any, any, infer Auth> ? Auth extends Authorization<any, any, any> ? ImpliedAuthFields<Auth> : object : object : object>;
+type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<T extends ModelTypeParamShape ? T['fields'][keyof T['fields']] extends ModelField<any, any, infer Auth> | ModelRelationshipField<any, any, any, infer Auth> | RefType<any, any, infer Auth> ? Auth extends Authorization<any, any, any> ? ImpliedAuthFields<Auth> : object : object : object>;
 export {};

package/dist/esm/MappedTypes/ResolveSchema.d.ts

@@ -1,6 +1,6 @@
 import type { ModelType } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
-import type { ModelRelationalField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationalField';
+import type { ModelRelationshipField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationshipField';
 import type { BaseModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
 import type { EnumType } from '../EnumType';
@@ -39,14 +39,14 @@ export type FieldTypes<T> = {
             array: false;
             arrayRequired: false;
             authorization: [];
-        }> | null : T[ModelProp][FieldProp] extends ModelRelationalField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : never;
+        }> | null : T[ModelProp][FieldProp] extends ModelRelationshipField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : never;
     };
 };
 /**
  * Resolves field types for a CustomType.
  *
  * This utility type is needed in addition to the `FieldTypes` utility type as
- * without checking `ModelRelationalField` can improve ~5% on resolving performance.
+ * without checking `ModelRelationshipField` can improve ~5% on resolving performance.
  *
  * Non-model types are replaced with Refs. Refs remain and are resolved in ResolveFieldProperties.ts
  */

package/dist/esm/ModelField.d.ts

@@ -42,6 +42,11 @@ type FieldData = {
     authorization: Authorization<any, any, any>[];
 };
 type ModelFieldTypeParamInner = string | number | boolean | Date | Json | null;
+/**
+ * A precise, recursive Json type blows the type calculation stack without installing
+ * explicit `Json extends T ? short-circuit : ...` type checks all over the place.
+ * We may take that on later. But, this is a good-enough approximation for now.
+ */
 export type Json = null | string | number | boolean | object | any[];
 export type ModelFieldTypeParamOuter = ModelFieldTypeParamInner | Array<ModelFieldTypeParamInner> | null;
 /**

package/dist/esm/{ModelRelationalField.d.ts → ModelRelationshipField.d.ts}

@@ -5,14 +5,17 @@ import { AllowModifier, Authorization } from './Authorization';
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
 export declare const __auth: unique symbol;
-declare const brandName = "modelRelationalField";
+declare const brandName = "modelRelationshipField";
+/**
+ * Model relationship types
+ */
 export declare enum ModelRelationshipTypes {
     hasOne = "hasOne",
     hasMany = "hasMany",
     belongsTo = "belongsTo"
 }
 type RelationshipTypes = `${ModelRelationshipTypes}`;
-type ModelRelationalFieldData = {
+type ModelRelationshipFieldData = {
     fieldType: 'model';
     type: ModelRelationshipTypes;
     relatedModel: string;
@@ -22,7 +25,7 @@ type ModelRelationalFieldData = {
     references: string[];
     authorization: Authorization<any, any, any>[];
 };
-export type ModelRelationalFieldParamShape = {
+export type ModelRelationshipFieldParamShape = {
     type: 'model';
     relationshipType: string;
     relatedModel: string;
@@ -31,33 +34,47 @@ export type ModelRelationalFieldParamShape = {
     references: string[];
     arrayRequired: boolean;
 };
-type ModelRelationalFieldFunctions<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never> = {
+type ModelRelationshipFieldFunctions<T extends ModelRelationshipFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationshipField<T, RM> = never> = {
     /**
      * When set, it requires the value of the relationship type to be required.
      */
-    valueRequired(): ModelRelationalField<SetTypeSubArg<T, 'valueRequired', true>, K | 'valueRequired'>;
+    valueRequired(): ModelRelationshipField<SetTypeSubArg<T, 'valueRequired', true>, K | 'valueRequired'>;
     /**
      * When set, it requires the relationship to always return a value
      */
-    required(): ModelRelationalField<SetTypeSubArg<T, 'arrayRequired', true>, K | 'required'>;
+    required(): ModelRelationshipField<SetTypeSubArg<T, 'arrayRequired', true>, K | 'required'>;
     /**
      * Configures field-level authorization rules. Pass in an array of authorizations `(allow => allow.____)` to mix and match
      * multiple authorization rules for this field.
      */
-    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRuleType | AuthRuleType[]): ModelRelationalField<T, K | 'authorization', K, AuthRuleType>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRuleType | AuthRuleType[]): ModelRelationshipField<T, K | 'authorization', K, AuthRuleType>;
 };
-export type ModelRelationalField<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never, Auth = undefined> = Omit<ModelRelationalFieldFunctions<T, RM, K>, K> & {
+/**
+ * Model relationship field definition interface
+ *
+ * @param T - The shape of the model relationship field
+ * @param RM - Adds structural separation with ModelField; easier to identify it when mapping to ClientTypes
+ * @param K - The keys already defined
+ */
+export type ModelRelationshipField<T extends ModelRelationshipFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationshipField<T, RM> = never, Auth = undefined> = Omit<ModelRelationshipFieldFunctions<T, RM, K>, K> & {
     [__auth]?: Auth;
 } & Brand<typeof brandName>;
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.
  */
-export type InternalRelationalField = ModelRelationalField<ModelRelationalFieldParamShape, string, never> & {
-    data: ModelRelationalFieldData;
+export type InternalRelationshipField = ModelRelationshipField<ModelRelationshipFieldParamShape, string, never> & {
+    data: ModelRelationshipFieldData;
 };
 export type RelationTypeFunctionOmitMapping<Type extends ModelRelationshipTypes> = Type extends ModelRelationshipTypes.belongsTo ? 'required' | 'valueRequired' : Type extends ModelRelationshipTypes.hasMany ? 'required' : Type extends ModelRelationshipTypes.hasOne ? 'valueRequired' : never;
-export type ModelRelationalTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean> = {
+/**
+ * Model relationship type definition content
+ *
+ * @param RM - The related model name
+ * @param RT - The relationship type
+ * @param IsArray - Whether the relationship is an array
+ */
+export type ModelRelationshipTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean> = {
     type: 'model';
     relatedModel: RM;
     relationshipType: RT;
@@ -91,7 +108,7 @@ export type ModelRelationalTypeArgFactory<RM extends string, RT extends Relation
  * @param references the field(s) that should be used to reference the related model
  * @returns a one-to-one relationship definition
  */
-export declare function hasOne<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>, RM, "valueRequired", undefined>;
+export declare function hasOne<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationshipField<ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>, RM, "valueRequired", undefined>;
 /**
  * Create a one-directional one-to-many relationship between two models using the `hasMany("MODEL_NAME", "REFERENCE_FIELD(s)")` method.
  * @example
@@ -118,7 +135,7 @@ export declare function hasOne<RM extends string>(relatedModel: RM, references:
  * @param references the field(s) that should be used to reference the related model
  * @returns a one-to-many relationship definition
  */
-export declare function hasMany<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>, RM, "required", undefined>;
+export declare function hasMany<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationshipField<ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>, RM, "required", undefined>;
 /**
  * Use `belongsTo()` to create a field to query the related `hasOne()` or `hasMany()` relationship.
  * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from
@@ -166,5 +183,5 @@ export declare function hasMany<RM extends string>(relatedModel: RM, references:
  * @param references the field(s) that should be used to reference the related model
  * @returns a belong-to relationship definition
  */
-export declare function belongsTo<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false>, RM, "required" | "valueRequired", undefined>;
+export declare function belongsTo<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationshipField<ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false>, RM, "required" | "valueRequired", undefined>;
 export {};

package/dist/esm/{ModelRelationalField.mjs → ModelRelationshipField.mjs}

@@ -4,6 +4,9 @@ import { allow } from './Authorization.mjs';
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
 const __auth = Symbol('__auth');
+/**
+ * Model relationship types
+ */
 var ModelRelationshipTypes;
 (function (ModelRelationshipTypes) {
     ModelRelationshipTypes["hasOne"] = "hasOne";
@@ -15,7 +18,7 @@ const relationModifierMap = {
     hasMany: ['valueRequired', 'authorization'],
     hasOne: ['required', 'authorization'],
 };
-function _modelRelationalField(type, relatedModel, references) {
+function _modelRelationshipField(type, relatedModel, references) {
     const data = {
         relatedModel,
         type,
@@ -77,7 +80,7 @@ function _modelRelationalField(type, relatedModel, references) {
  * @returns a one-to-one relationship definition
  */
 function hasOne(relatedModel, references) {
-    return _modelRelationalField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);
+    return _modelRelationshipField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);
 }
 /**
  * Create a one-directional one-to-many relationship between two models using the `hasMany("MODEL_NAME", "REFERENCE_FIELD(s)")` method.
@@ -106,7 +109,7 @@ function hasOne(relatedModel, references) {
  * @returns a one-to-many relationship definition
  */
 function hasMany(relatedModel, references) {
-    return _modelRelationalField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);
+    return _modelRelationshipField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);
 }
 /**
  * Use `belongsTo()` to create a field to query the related `hasOne()` or `hasMany()` relationship.
@@ -156,8 +159,8 @@ function hasMany(relatedModel, references) {
  * @returns a belong-to relationship definition
  */
 function belongsTo(relatedModel, references) {
-    return _modelRelationalField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);
+    return _modelRelationshipField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);
 }
 
 export { ModelRelationshipTypes, __auth, belongsTo, hasMany, hasOne };
-//# sourceMappingURL=ModelRelationalField.mjs.map
+//# sourceMappingURL=ModelRelationshipField.mjs.map

package/dist/esm/ModelRelationshipField.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelRelationshipField.mjs","sources":["../../src/ModelRelationshipField.ts"],"sourcesContent":["import { allow } from './Authorization';\n/**\n * Used to \"attach\" auth types to ModelField without exposing them on the builder.\n */\nexport const __auth = Symbol('__auth');\nconst brandName = 'modelRelationshipField';\n/**\n * Model relationship types\n */\nexport var ModelRelationshipTypes;\n(function (ModelRelationshipTypes) {\n    ModelRelationshipTypes[\"hasOne\"] = \"hasOne\";\n    ModelRelationshipTypes[\"hasMany\"] = \"hasMany\";\n    ModelRelationshipTypes[\"belongsTo\"] = \"belongsTo\";\n})(ModelRelationshipTypes || (ModelRelationshipTypes = {}));\nconst relationshipModifiers = [\n    'required',\n    'valueRequired',\n    'authorization',\n];\nconst relationModifierMap = {\n    belongsTo: ['authorization'],\n    hasMany: ['valueRequired', 'authorization'],\n    hasOne: ['required', 'authorization'],\n};\nfunction _modelRelationshipField(type, relatedModel, references) {\n    const data = {\n        relatedModel,\n        type,\n        fieldType: 'model',\n        array: false,\n        valueRequired: false,\n        arrayRequired: false,\n        references,\n        authorization: [],\n    };\n    data.array = type === 'hasMany';\n    const relationshipBuilderFunctions = {\n        required() {\n            data.arrayRequired = true;\n            return this;\n        },\n        valueRequired() {\n            data.valueRequired = true;\n            return this;\n        },\n        authorization(callback) {\n            const rules = callback(allow);\n            data.authorization = Array.isArray(rules) ? rules : [rules];\n            return this;\n        },\n    };\n    const builder = Object.fromEntries(relationModifierMap[type].map((key) => [\n        key,\n        relationshipBuilderFunctions[key],\n    ]));\n    return {\n        ...builder,\n        data,\n    };\n}\n/**\n * Create one-to-one relationship between two models using the `hasOne(\"MODEL_NAME\", \"REFERENCE_FIELD(s)\")` method.\n * A hasOne relationship always uses a reference to the related model's identifier. Typically this is the `id` field\n * unless overwritten with the `identifier()` method.\n * @example\n * const schema = a.schema({\n *   Cart: a.model({\n *     items: a.string().required().array(),\n *     // 1. Create reference field\n *     customerId: a.id(),\n *     // 2. Create relationship field with the reference field\n *     customer: a.belongsTo('Customer', 'customerId'),\n *   }),\n *   Customer: a.model({\n *     name: a.string(),\n *     // 3. Create relationship field with the reference field\n *     //    from the Cart model\n *     activeCart: a.hasOne('Cart', 'customerId')\n *   }),\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/#model-a-one-to-one-relationship}\n * @param relatedModel the name of the related model\n * @param references the field(s) that should be used to reference the related model\n * @returns a one-to-one relationship definition\n */\nexport function hasOne(relatedModel, references) {\n    return _modelRelationshipField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);\n}\n/**\n * Create a one-directional one-to-many relationship between two models using the `hasMany(\"MODEL_NAME\", \"REFERENCE_FIELD(s)\")` method.\n * @example\n * const schema = a.schema({\n *   Member: a.model({\n *     name: a.string().required(),\n *     // 1. Create a reference field\n *     teamId: a.id(),\n *     // 2. Create a belongsTo relationship with the reference field\n *     team: a.belongsTo('Team', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n *\n *   Team: a.model({\n *     mantra: a.string().required(),\n *     // 3. Create a hasMany relationship with the reference field\n *     //    from the `Member`s model.\n *     members: a.hasMany('Member', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/#model-one-to-many-relationships}\n * @param relatedModel the name of the related model\n * @param references the field(s) that should be used to reference the related model\n * @returns a one-to-many relationship definition\n */\nexport function hasMany(relatedModel, references) {\n    return _modelRelationshipField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);\n}\n/**\n * Use `belongsTo()` to create a field to query the related `hasOne()` or `hasMany()` relationship.\n * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from\n * parent to the related model.\n *\n * @example\n * // one-to-many relationship\n * const schema = a.schema({\n *   Member: a.model({\n *     name: a.string().required(),\n *     // 1. Create a reference field\n *     teamId: a.id(),\n *     // 2. Create a belongsTo relationship with the reference field\n *     team: a.belongsTo('Team', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n *\n *   Team: a.model({\n *     mantra: a.string().required(),\n *     // 3. Create a hasMany relationship with the reference field\n *     //    from the `Member`s model.\n *     members: a.hasMany('Member', 'teamId'),\n *   })\n *   .authorization(allow => [allow.publicApiKey()]),\n * });\n * @example\n * // one-to-one relationship\n * const schema = a.schema({\n *   Cart: a.model({\n *     items: a.string().required().array(),\n *     // 1. Create reference field\n *     customerId: a.id(),\n *     // 2. Create relationship field with the reference field\n *     customer: a.belongsTo('Customer', 'customerId'),\n *   }),\n *   Customer: a.model({\n *     name: a.string(),\n *     // 3. Create relationship field with the reference field\n *     //    from the Cart model\n *     activeCart: a.hasOne('Cart', 'customerId')\n *   }),\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/}\n * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model\n * @param references the field(s) that should be used to reference the related model\n * @returns a belong-to relationship definition\n */\nexport function belongsTo(relatedModel, references) {\n    return _modelRelationshipField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/ModelSchema.d.ts

@@ -5,7 +5,7 @@ import type { CustomType, CustomTypeParamShape } from './CustomType';
 import type { CustomOperation, CustomOperationParamShape, InternalCustom, MutationCustomOperation, QueryCustomOperation, SubscriptionCustomOperation } from './CustomOperation';
 import { AllowModifier, SchemaAuthorization } from './Authorization';
 import { Brand, RenameUsingTuples } from './util';
-import { ModelRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
+import { ModelRelationshipField, ModelRelationshipFieldParamShape } from './ModelRelationshipField';
 import { ConversationType } from './ai/ConversationType';
 export { ModelType } from './ModelType';
 export { EnumType } from './EnumType';
@@ -50,6 +50,12 @@ export type BaseSchema<T extends ModelSchemaParamShape, IsRDS extends boolean =
     };
 };
 export type GenericModelSchema<T extends ModelSchemaParamShape> = BaseSchema<T> & Brand<typeof rdsSchemaBrandName | typeof ddbSchemaBrandName>;
+/**
+ * Model schema definition interface
+ *
+ * @param T - The shape of the model schema
+ * @param UsedMethods - The method keys already defined
+ */
 export type ModelSchema<T extends ModelSchemaParamShape, UsedMethods extends 'authorization' | 'relationships' = never> = Omit<{
     authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRules | AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
 }, UsedMethods> & BaseSchema<T> & DDBSchemaBrand;
@@ -57,7 +63,7 @@ type RDSModelSchemaFunctions = 'addToSchema' | 'addQueries' | 'addMutations' | '
 type OmitFromEach<Models, Modifier extends string> = {
     [ModelName in keyof Models]: Omit<Models[ModelName], Modifier>;
 };
-type RelationshipTemplate = Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>>;
+type RelationshipTemplate = Record<string, ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>>;
 export type RDSModelSchema<T extends RDSModelSchemaParamShape, UsedMethods extends RDSModelSchemaFunctions = never> = Omit<{
     addToSchema: <AddedTypes extends AddToSchemaContents>(types: AddedTypes) => RDSModelSchema<SetTypeSubArg<T, 'types', T['types'] & AddedTypes>, UsedMethods | 'addToSchema'>;
     /**
@@ -83,7 +89,7 @@ export type RDSModelSchema<T extends RDSModelSchemaParamShape, UsedMethods exten
  * Amplify API Next Model Schema shape
  */
 export type ModelSchemaType = ModelSchema<ModelSchemaParamShape>;
-type ModelWithRelationships<Types extends Record<string, any>, Relationships extends ReadonlyArray<Record<string, RelationshipTemplate | undefined>>, ModelName extends keyof Types, RelationshipMap extends UnionToIntersection<Relationships[number]> = UnionToIntersection<Relationships[number]>> = ModelName extends keyof RelationshipMap ? RelationshipMap[ModelName] extends Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>> ? AddRelationshipFieldsToModelTypeFields<Types[ModelName], RelationshipMap[ModelName]> : Types[ModelName] : Types[ModelName];
+type ModelWithRelationships<Types extends Record<string, any>, Relationships extends ReadonlyArray<Record<string, RelationshipTemplate | undefined>>, ModelName extends keyof Types, RelationshipMap extends UnionToIntersection<Relationships[number]> = UnionToIntersection<Relationships[number]>> = ModelName extends keyof RelationshipMap ? RelationshipMap[ModelName] extends Record<string, ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>> ? AddRelationshipFieldsToModelTypeFields<Types[ModelName], RelationshipMap[ModelName]> : Types[ModelName] : Types[ModelName];
 /**
  * Model Schema type guard
  * @param schema - api-next ModelSchema or string

package/dist/esm/ModelType.d.ts

@@ -1,7 +1,7 @@
 import type { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import { type PrimaryIndexIrShape, type SecondaryIndexIrShape } from './util';
 import type { InternalField, BaseModelField } from './ModelField';
-import type { ModelRelationalField, InternalRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
+import type { ModelRelationshipField, InternalRelationshipField, ModelRelationshipFieldParamShape } from './ModelRelationshipField';
 import { type AllowModifier, type Authorization } from './Authorization';
 import type { RefType, RefTypeParamShape } from './RefType';
 import type { EnumType } from './EnumType';
@@ -12,8 +12,8 @@ import type { brandSymbol } from './util/Brand.js';
 import type { methodKeyOf } from './util/usedMethods.js';
 declare const brandName = "modelType";
 export type deferredRefResolvingPrefix = 'deferredRefResolving:';
-type ModelFields = Record<string, BaseModelField | ModelRelationalField<any, string, any, any> | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
-type InternalModelFields = Record<string, InternalField | InternalRelationalField>;
+type ModelFields = Record<string, BaseModelField | ModelRelationshipField<any, string, any, any> | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
+type InternalModelFields = Record<string, InternalField | InternalRelationshipField>;
 export type DisableOperationsOptions = 'queries' | 'mutations' | 'subscriptions' | 'list' | 'get' | 'create' | 'update' | 'delete' | 'onCreate' | 'onUpdate' | 'onDelete';
 type ModelData = {
     fields: ModelFields;
@@ -54,9 +54,15 @@ export type ModelTypeParamShape = {
 export type ExtractSecondaryIndexIRFields<T extends ModelTypeParamShape, RequiredOnly extends boolean = false> = {
     [FieldProp in keyof T['fields'] as T['fields'][FieldProp] extends BaseModelField<infer R> ? NonNullable<R> extends string | number ? RequiredOnly extends false ? FieldProp : null extends R ? never : FieldProp : never : T['fields'][FieldProp] extends EnumType | RefType<RefTypeParamShape, any, any> ? FieldProp : never]: T['fields'][FieldProp] extends BaseModelField<infer R> ? R : T['fields'][FieldProp] extends EnumType<infer values> ? values[number] : T['fields'][FieldProp] extends RefType<infer R, any, any> ? `${deferredRefResolvingPrefix}${R['link']}` : never;
 };
-export type AddRelationshipFieldsToModelTypeFields<Model, RelationshipFields extends Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>>> = Model extends ModelType<infer ModelParam extends ModelTypeParamShape, infer HiddenKeys> ? ModelType<SetTypeSubArg<ModelParam, 'fields', ModelParam['fields'] & RelationshipFields>, HiddenKeys> : never;
+export type AddRelationshipFieldsToModelTypeFields<Model, RelationshipFields extends Record<string, ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>>> = Model extends ModelType<infer ModelParam extends ModelTypeParamShape, infer HiddenKeys> ? ModelType<SetTypeSubArg<ModelParam, 'fields', ModelParam['fields'] & RelationshipFields>, HiddenKeys> : never;
 export type BaseModelType<T extends ModelTypeParamShape = ModelTypeParamShape> = ModelType<T, UsableModelTypeKey>;
 export type UsableModelTypeKey = methodKeyOf<ModelType>;
+/**
+ * Model type definition interface
+ *
+ * @param T - The shape of the model type
+ * @param UsedMethod - The method keys already defined
+ */
 export type ModelType<T extends ModelTypeParamShape = ModelTypeParamShape, UsedMethod extends UsableModelTypeKey = never> = Omit<{
     [brandSymbol]: typeof brandName;
     identifier<PrimaryIndexFields = ExtractSecondaryIndexIRFields<T, true>, PrimaryIndexPool extends string = keyof PrimaryIndexFields & string, const ID extends ReadonlyArray<PrimaryIndexPool> = readonly [], const PrimaryIndexIR extends PrimaryIndexIrShape = PrimaryIndexFieldsToIR<ID, PrimaryIndexFields>>(identifier: ID): ModelType<SetTypeSubArg<T, 'identifier', PrimaryIndexIR>, UsedMethod | 'identifier'>;
@@ -69,7 +75,7 @@ export type ModelType<T extends ModelTypeParamShape = ModelTypeParamShape, UsedM
  * Used on the complete schema object.
  */
 export type SchemaModelType<T extends BaseModelType = ModelType<ModelTypeParamShape, 'identifier'>, ModelName extends string = string, IsRDS extends boolean = false> = IsRDS extends true ? T & {
-    relationships<Param extends Record<string, ModelRelationalField<any, string, any, any>> = Record<never, never>>(relationships: Param): Record<ModelName, Param>;
+    relationships<Param extends Record<string, ModelRelationshipField<any, string, any, any>> = Record<never, never>>(relationships: Param): Record<ModelName, Param>;
     fields: T extends ModelType<infer R, any> ? R['fields'] : never;
 } : T;
 /**
@@ -85,6 +91,13 @@ export type InternalModel = SchemaModelType<ModelType<ModelTypeParamShape>, stri
  * @returns true if the given value is a ModelSchema
  */
 export declare const isSchemaModelType: (modelType: any | SchemaModelType) => modelType is ModelType<ModelTypeParamShape, "identifier">;
+/**
+ * Model default identifier
+ *
+ * @param pk - primary key
+ * @param sk - secondary key
+ * @param compositeSk - composite secondary key
+ */
 export type ModelDefaultIdentifier = {
     pk: {
         readonly id: string;

package/dist/esm/RefType.d.ts

@@ -21,6 +21,12 @@ export type RefTypeParamShape = {
     authorization: Authorization<any, any, any>[];
 };
 type MutationOperations = 'create' | 'update' | 'delete';
+/**
+ * Reference type definition interface
+ *
+ * @param T - The shape of the reference type
+ * @param K - The keys already defined
+ */
 export type RefType<T extends RefTypeParamShape, K extends keyof RefType<T> = never, Auth = undefined> = Omit<{
     /**
      * Marks a field as required.

package/dist/esm/SchemaProcessor.mjs

@@ -1,5 +1,5 @@
 import { ModelFieldType, string, __generated } from './ModelField.mjs';
-import { ModelRelationshipTypes } from './ModelRelationalField.mjs';
+import { ModelRelationshipTypes } from './ModelRelationshipField.mjs';
 import { accessData, accessSchemaData } from './Authorization.mjs';
 import { CustomOperationNames } from './CustomOperation.mjs';
 import { getBrand, brandSymbol } from './util/Brand.mjs';
@@ -158,7 +158,9 @@ function transformFunctionHandler(handlers, functionFieldName) {
         else if (typeof handlerData.handler.getInstance === 'function') {
             const fnName = `Fn${capitalize(functionFieldName)}${idx === 0 ? '' : `${idx + 1}`}`;
             lambdaFunctionDefinition[fnName] = handlerData.handler;
-            const invocationTypeArg = handlerData.invocationType === 'Event' ? ', invocationType: Event)' : ')';
+            const invocationTypeArg = handlerData.invocationType === 'Event'
+                ? ', invocationType: Event)'
+                : ')';
             gqlHandlerContent += `@function(name: "${fnName}"${invocationTypeArg} `;
         }
         else {
@@ -837,11 +839,12 @@ const schemaPreprocessor = (schema) => {
     // - it only happens once per schema
     // - downstream validation based on `getRefTypeForSchema` finds the EventInvocationResponse type
     const containsAsyncLambdaCustomOperation = Object.entries(schema.data.types).find(([_, typeDef]) => {
-        return isCustomOperation(typeDef)
-            && finalHandlerIsAsyncFunctionHandler(typeDef.data.handlers);
+        return (isCustomOperation(typeDef) &&
+            finalHandlerIsAsyncFunctionHandler(typeDef.data.handlers));
     });
     if (containsAsyncLambdaCustomOperation) {
-        schema.data.types['EventInvocationResponse'] = eventInvocationResponseCustomType;
+        schema.data.types['EventInvocationResponse'] =
+            eventInvocationResponseCustomType;
     }
     const topLevelTypes = sortTopLevelTypes(Object.entries(schema.data.types));
     const { schemaAuth, functionSchemaAccess } = extractFunctionSchemaAccess(schema.data.authorization);
@@ -1019,7 +1022,9 @@ function validateCustomOperations(typeDef, typeName, authRules, getRefType) {
         (opType === 'Query' || opType === 'Mutation' || opType === 'Generation')) {
         // TODO: There should be a more elegant and readable way to handle this check.
         // Maybe it's not even necessary anymore since we're the setting returnType in the handler() method.
-        if (!handlers || handlers.length === 0 || handlers[handlers.length - 1][brandSymbol] !== 'asyncFunctionHandler') {
+        if (!handlers ||
+            handlers.length === 0 ||
+            handlers[handlers.length - 1][brandSymbol] !== 'asyncFunctionHandler') {
             const typeDescription = opType === 'Generation' ? 'Generation Route' : `Custom ${opType}`;
             throw new Error(`Invalid ${typeDescription} definition. A ${typeDescription} must include a return type. ${typeName} has no return type specified.`);
         }
@@ -1077,10 +1082,12 @@ const isCustomHandler = (handler) => {
     return Array.isArray(handler) && getBrand(handler[0]) === 'customHandler';
 };
 const isFunctionHandler = (handler) => {
-    return Array.isArray(handler) && ['functionHandler', 'asyncFunctionHandler'].includes(getBrand(handler[0]));
+    return (Array.isArray(handler) &&
+        ['functionHandler', 'asyncFunctionHandler'].includes(getBrand(handler[0])));
 };
 const finalHandlerIsAsyncFunctionHandler = (handler) => {
-    return Array.isArray(handler) && getBrand(handler[handler.length - 1]) === 'asyncFunctionHandler';
+    return (Array.isArray(handler) &&
+        getBrand(handler[handler.length - 1]) === 'asyncFunctionHandler');
 };
 const normalizeDataSourceName = (dataSource) => {
     // default data source
@@ -1143,11 +1150,11 @@ const eventInvocationResponseCustomType = {
                     required: true,
                     array: false,
                     arrayRequired: false,
-                }
-            }
+                },
+            },
         },
-        type: 'customType'
-    }
+        type: 'customType',
+    },
 };
 function transformCustomOperations(typeDef, typeName, authRules, databaseType, getRefType) {
     const { typeName: opType, handlers } = typeDef.data;
@@ -1239,8 +1246,8 @@ function validateRelationships(typeName, record, getInternalModel) {
         // Create a structure representing the relationship for validation.
         const relationship = getModelRelationship(typeName, { name: name, def: field.data }, getInternalModel);
         // Validate that the references defined in the relationship follow the
-        // relational definition rules.
-        validateRelationalReferences(relationship);
+        // relationship definition rules.
+        validateRelationshipReferences(relationship);
     }
 }
 /**
@@ -1266,7 +1273,7 @@ function describeConnectFieldRelationship(sourceField, sourceModelName) {
  * Validates that the types of child model's reference fields match the types of the parent model's identifier fields.
  * @param relationship The {@link ModelRelationship} to validate.
  */
-function validateRelationalReferences(relationship) {
+function validateRelationshipReferences(relationship) {
     const { parent, parentConnectionField, child, childConnectionField, references, } = relationship;
     const parentIdentifiers = getIndentifierTypes(parent);
     const childReferenceTypes = [];
@@ -1373,7 +1380,7 @@ function getAssociatedConnectionField(sourceModelName, sourceConnectionField, as
         }
         // In order to find that associated connection field, we need to do some validation that we'll depend on further downstream.
         // 1. Field type matches the source model's type.
-        // 2. A valid counterpart relational modifier is defined on the field. See `associatedRelationshipTypes` for more information.
+        // 2. A valid counterpart relationship modifier is defined on the field. See `associatedRelationshipTypes` for more information.
         // 3. The reference arguments provided to the field match (element count + string comparison) references passed to the source connection field.
         return (connectionField.data.relatedModel === sourceModelName &&
             associatedRelationshipOptions.includes(connectionField.data.type) &&