@aws-amplify/data-schema 1.9.2 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/data-schema",
-  "version": "1.9.2",
+  "version": "1.10.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/src/Authorization.ts

@@ -103,6 +103,13 @@ export type ResourceAuthorizationData = {
   operations?: ResourceOperation[];
 };
 
+/**
+ * Container for authorization schema definition content.
+ *
+ * @param AuthStrategy The auth strategy to use.
+ * @param AuthField The field to use for owner authorization.
+ * @param AuthFieldPlurality Whether the field is plural or singular.
+ */
 export type Authorization<
   AuthStrategy extends Strategy,
   AuthField extends string | undefined,

package/src/ClientSchema/Core/ClientModel.ts

@@ -14,7 +14,7 @@ import type {
   Prettify,
 } from '@aws-amplify/data-schema-types';
 import type { ModelField } from '../../ModelField';
-import type { ModelRelationalField } from '../../ModelRelationalField';
+import type { ModelRelationshipField } from '../../ModelRelationshipField';
 import type { EnumType } from '../../EnumType';
 import type { CustomType, CustomTypeParamShape } from '../../CustomType';
 import type { RefType } from '../../RefType';
@@ -164,7 +164,7 @@ type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<
   T extends ModelTypeParamShape
     ? T['fields'][keyof T['fields']] extends
         | ModelField<any, any, infer Auth>
-        | ModelRelationalField<any, any, any, infer Auth>
+        | ModelRelationshipField<any, any, any, infer Auth>
         | RefType<any, any, infer Auth>
       ? Auth extends Authorization<any, any, any>
         ? ImpliedAuthFields<Auth>
@@ -267,7 +267,7 @@ export type IndexQueryInput<
  */
 
 /**
- * All required fields and relational fields, exclude readonly fields
+ * All required fields and relationship fields, exclude readonly fields
  */
 type MutationInput<
   Model extends ClientModel<any, any, any, any, any>,

package/src/ClientSchema/utilities/ResolveField.ts

@@ -1,8 +1,8 @@
 import { BaseModelField } from '../../ModelField';
 import {
-  ModelRelationalField,
-  ModelRelationalFieldParamShape,
-} from '../../ModelRelationalField';
+  ModelRelationshipField,
+  ModelRelationshipFieldParamShape,
+} from '../../ModelRelationshipField';
 import { EnumType } from '../../EnumType';
 import { CustomType } from '../../CustomType';
 import { RefType, RefTypeParamShape } from '../../RefType';
@@ -43,7 +43,7 @@ export type ResolveIndividualField<Bag extends Record<string, any>, T> =
     ? FieldShape
     : T extends RefType<infer RefShape, any, any>
       ? ResolveRef<RefShape, Bag>
-      : T extends ModelRelationalField<infer RelationshipShape, any, any, any>
+      : T extends ModelRelationshipField<infer RelationshipShape, any, any, any>
         ? ResolveRelationship<Bag, RelationshipShape>
         : T extends CustomType<infer CT>
           ? ResolveFields<Bag, CT['fields']> | null
@@ -56,20 +56,20 @@ export type ResolveIndividualField<Bag extends Record<string, any>, T> =
  */
 type ResolveRelationship<
   Bag extends Record<string, any>,
-  RelationshipShape extends ModelRelationalFieldParamShape,
-> = DependentLazyLoaderOpIsAvailable<Bag, RelationshipShape> extends true
+  RelationshipShape extends ModelRelationshipFieldParamShape,
+> =
+  DependentLazyLoaderOpIsAvailable<Bag, RelationshipShape> extends true
     ? LazyLoader<
         RelationshipShape['valueRequired'] extends true
           ? Bag[RelationshipShape['relatedModel']]['type']
           : Bag[RelationshipShape['relatedModel']]['type'] | null,
         RelationshipShape['array']
       >
-    : never
-;
+    : never;
 
 type DependentLazyLoaderOpIsAvailable<
   Bag extends Record<string, any>,
-  RelationshipShape extends ModelRelationalFieldParamShape,
+  RelationshipShape extends ModelRelationshipFieldParamShape,
 > = RelationshipShape['relationshipType'] extends 'hasOne' | 'hasMany'
   ? // hasOne and hasMany depend on `list`
     'list' extends keyof Bag[RelationshipShape['relatedModel']]['__meta']['disabledOperations']
@@ -78,8 +78,7 @@ type DependentLazyLoaderOpIsAvailable<
   : // the relationship is a belongsTo, which depends on `get`
     'get' extends keyof Bag[RelationshipShape['relatedModel']]['__meta']['disabledOperations']
     ? false
-    : true
-;
+    : true;
 
 type IsRequired<T> =
   T extends BaseModelField<infer FieldShape>
@@ -88,7 +87,7 @@ type IsRequired<T> =
       : true
     : T extends RefType<infer RefShape, any, any>
       ? IsRefRequired<RefShape>
-      : T extends ModelRelationalField<any, any, any, any>
+      : T extends ModelRelationshipField<any, any, any, any>
         ? true
         : T extends CustomType<any> | EnumType<any>
           ? false

package/src/CustomOperation.ts

@@ -92,6 +92,13 @@ export type CustomOperationParamShape = {
   input?: CustomOperationInput;
 };
 
+/**
+ * Custom operation definition interface
+ *
+ * @param T - The shape of the custom operation
+ * @param K - The keys already defined
+ * @param B - The brand of the custom operation
+ */
 export type CustomOperation<
   T extends CustomOperationParamShape,
   K extends keyof CustomOperation<T> = never,

package/src/CustomType.ts

@@ -36,6 +36,11 @@ export type CustomTypeParamShape = {
   fields: CustomTypeFields;
 };
 
+/**
+ * Custom type container
+ *
+ * @param T - The shape of the custom type container
+ */
 export type CustomType<T extends CustomTypeParamShape> = T &
   Brand<'customType'>;
 
@@ -57,7 +62,7 @@ function _customType<T extends CustomTypeParamShape>(fields: T['fields']) {
 }
 
 /**
- * Define a custom type. This type represents an inline, typed JSON object. 
+ * Define a custom type. This type represents an inline, typed JSON object.
  * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/add-fields/#specify-a-custom-field-type}
  * @param fields the fields to be added to the custom type
  * @returns a custom type
@@ -77,12 +82,12 @@ function _customType<T extends CustomTypeParamShape>(fields: T['fields']) {
  *       lat: a.float(),
  *       long: a.float(),
  *   }),
- * 
+ *
  *   Post: a.model({
  *     location: a.ref('Location'),
  *     content: a.string(),
  *   }),
- * 
+ *
  *   User: a.model({
  *     lastKnownLocation: a.ref('Location'),
  *   }),

package/src/EnumType.ts

@@ -6,6 +6,11 @@ type EnumTypeParamShape<values extends readonly string[] = readonly string[]> =
     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/src/MappedTypes/ModelMetadata.ts

@@ -5,7 +5,7 @@ import {
 import { __modelMeta__ } from '../runtime/';
 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>
@@ -23,7 +23,7 @@ export type ModelSecondaryIndexes<T> = {
     : never;
 };
 
-export type RelationalMetadata<
+export type RelationshipMetadata<
   ResolvedSchema,
   ResolvedFields extends Record<string, unknown>,
   IdentifierMeta extends Record<string, { identifier: PrimaryIndexIrShape }>,
@@ -31,7 +31,7 @@ export type RelationalMetadata<
   ExcludeEmpty<
     {
       [ModelName in keyof ResolvedSchema]: {
-        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape
+        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape
           ? ResolvedSchema[ModelName][Field]['relationshipType'] extends
               | 'hasOne'
               | 'belongsTo'
@@ -39,11 +39,11 @@ export type RelationalMetadata<
               // E.g. if Post hasOne Author, we need to add a postAuthorId field to the Post model
               ModelName
             : never
-          : never]: ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape
-          ? ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape
+          : never]: ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape
+          ? ResolvedSchema[ModelName][Field] extends ModelRelationshipFieldParamShape
             ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasMany'
               ? {
-                  relationalInputFields: Partial<
+                  relationshipInputFields: Partial<
                     Record<
                       // For M:N and 1:M we add a parent model field to the child
                       `${Uncapitalize<ModelName & string>}`,
@@ -55,7 +55,7 @@ export type RelationalMetadata<
                   >;
                 }
               : {
-                  relationalInputFields: Partial<
+                  relationshipInputFields: Partial<
                     Record<
                       // For 1:1 and Belongs To we add a child model field to the parent
                       Field,

package/src/MappedTypes/ResolveFieldProperties.ts

@@ -7,9 +7,9 @@ import type { ModelField } from '../ModelField';
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
 import type {
-  ModelRelationalField,
-  ModelRelationalFieldParamShape,
-} from '../ModelRelationalField';
+  ModelRelationshipField,
+  ModelRelationshipFieldParamShape,
+} from '../ModelRelationshipField';
 import type { PrimaryIndexIrShape } from '../util/';
 
 import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
@@ -38,7 +38,7 @@ export type ResolveFieldProperties<
     ResolvedSchema,
     IdentifierMeta
   >,
-  FieldsWithRelationships = ResolveModelsRelationalAndRefFields<
+  FieldsWithRelationships = ResolveModelsRelationshipAndRefFields<
     FieldsWithInjectedImplicitFields,
     NonModelTypes
   >,
@@ -59,7 +59,7 @@ export type ResolveStaticFieldProperties<
     ResolvedSchema & ImplicitModelsSchema,
     never
   >,
-  FieldsWithRelationships = ResolveModelsRelationalAndRefFields<
+  FieldsWithRelationships = ResolveModelsRelationshipAndRefFields<
     FieldsWithInjectedImplicitFields,
     NonModelTypes
   >,
@@ -73,20 +73,20 @@ export type ResolveStaticFieldProperties<
 type GetRelationshipRef<
   T,
   RM extends keyof T,
-  TypeArg extends ModelRelationalFieldParamShape,
+  TypeArg extends ModelRelationshipFieldParamShape,
   Flat extends boolean,
-  ResolvedModel = ResolveRelationalFieldsForModel<T, RM, Flat>,
+  ResolvedModel = ResolveRelationshipFieldsForModel<T, RM, Flat>,
   Model = TypeArg['valueRequired'] extends true
     ? ResolvedModel
     : ResolvedModel | null | undefined,
 > = LazyLoader<Model, TypeArg['array']>;
 
-type ResolveRelationalFieldsForModel<
+type ResolveRelationshipFieldsForModel<
   Schema,
   ModelName extends keyof Schema,
   Flat extends boolean,
 > = {
-  [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationalFieldParamShape
+  [FieldName in keyof Schema[ModelName]]: Schema[ModelName][FieldName] extends ModelRelationshipFieldParamShape
     ? Schema[ModelName][FieldName]['relatedModel'] extends keyof Schema
       ? GetRelationshipRef<
           Schema,
@@ -147,7 +147,7 @@ export type ResolveFieldRequirements<Resolved> = Intersection<
   ExtractNonNullableFieldsToRequiredFields<Resolved>
 >;
 
-type ResolveModelsRelationalAndRefFields<
+type ResolveModelsRelationshipAndRefFields<
   Schema,
   NonModelTypes extends NonModelTypesShape,
   Flat extends boolean = false,
@@ -159,7 +159,7 @@ type ResolveModelsRelationalAndRefFields<
       any
     > | null
       ? ResolveRef<NonModelTypes, R>
-      : Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape
+      : Schema[ModelProp][FieldProp] extends ModelRelationshipFieldParamShape
         ? Schema[ModelProp][FieldProp]['relatedModel'] extends keyof Schema
           ? GetRelationshipRef<
               Schema,
@@ -167,7 +167,7 @@ type ResolveModelsRelationalAndRefFields<
               Schema[ModelProp][FieldProp],
               Flat
             >
-          : never // if the field value extends ModelRelationalFieldShape "relatedModel" should always point to a Model (keyof Schema)
+          : never // if the field value extends ModelRelationshipFieldShape "relatedModel" should always point to a Model (keyof Schema)
         : Schema[ModelProp][FieldProp];
   };
 };
@@ -245,7 +245,7 @@ type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<
   T extends ModelTypeParamShape
     ? T['fields'][keyof T['fields']] extends
         | ModelField<any, any, infer Auth>
-        | ModelRelationalField<any, any, any, infer Auth>
+        | ModelRelationshipField<any, any, any, infer Auth>
         | RefType<any, any, infer Auth>
       ? Auth extends Authorization<any, any, any>
         ? ImpliedAuthFields<Auth>

package/src/MappedTypes/ResolveSchema.ts

@@ -1,10 +1,10 @@
 import type { ModelType } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
 import type {
-  ModelRelationalField,
+  ModelRelationshipField,
   ModelRelationshipTypes,
   RelationTypeFunctionOmitMapping,
-} from '../ModelRelationalField';
+} from '../ModelRelationshipField';
 import type { BaseModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
 import type { EnumType } from '../EnumType';
@@ -91,8 +91,8 @@ export type FieldTypes<T> = {
               arrayRequired: false;
               authorization: [];
             }> | null
-          : // resolve relational and model fields to the their first type arg
-            T[ModelProp][FieldProp] extends ModelRelationalField<
+          : // resolve relationship and model fields to the their first type arg
+            T[ModelProp][FieldProp] extends ModelRelationshipField<
                 infer R,
                 string,
                 RelationTypeFunctionOmitMapping<ModelRelationshipTypes>,
@@ -107,7 +107,7 @@ export type FieldTypes<T> = {
  * 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/src/ModelField.ts

@@ -55,9 +55,11 @@ type FieldData = {
 
 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.
+/**
+ * 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 =

package/src/{ModelRelationalField.ts → ModelRelationshipField.ts}

@@ -7,8 +7,11 @@ import { AllowModifier, Authorization, allow } from './Authorization';
  */
 export const __auth = Symbol('__auth');
 
-const brandName = 'modelRelationalField';
+const brandName = 'modelRelationshipField';
 
+/**
+ * Model relationship types
+ */
 export enum ModelRelationshipTypes {
   hasOne = 'hasOne',
   hasMany = 'hasMany',
@@ -17,7 +20,7 @@ export enum ModelRelationshipTypes {
 
 type RelationshipTypes = `${ModelRelationshipTypes}`;
 
-type ModelRelationalFieldData = {
+type ModelRelationshipFieldData = {
   fieldType: 'model';
   type: ModelRelationshipTypes;
   relatedModel: string;
@@ -28,7 +31,7 @@ type ModelRelationalFieldData = {
   authorization: Authorization<any, any, any>[];
 };
 
-export type ModelRelationalFieldParamShape = {
+export type ModelRelationshipFieldParamShape = {
   type: 'model';
   relationshipType: string;
   relatedModel: string;
@@ -38,23 +41,23 @@ export type ModelRelationalFieldParamShape = {
   arrayRequired: boolean;
 };
 
-type ModelRelationalFieldFunctions<
-  T extends ModelRelationalFieldParamShape,
+type ModelRelationshipFieldFunctions<
+  T extends ModelRelationshipFieldParamShape,
   // RM adds structural separation with ModelField; easier to identify it when mapping to ClientTypes
   RM extends string | symbol,
-  K extends keyof ModelRelationalField<T, RM> = never,
+  K extends keyof ModelRelationshipField<T, RM> = never,
 > = {
   /**
    * When set, it requires the value of the relationship type to be required.
    */
-  valueRequired(): ModelRelationalField<
+  valueRequired(): ModelRelationshipField<
     SetTypeSubArg<T, 'valueRequired', true>,
     K | 'valueRequired'
   >;
   /**
    * When set, it requires the relationship to always return a value
    */
-  required(): ModelRelationalField<
+  required(): ModelRelationshipField<
     // The RM generic cannot be "required" since no such field exists
     SetTypeSubArg<T, 'arrayRequired', true>,
     K | 'required'
@@ -65,16 +68,22 @@ type ModelRelationalFieldFunctions<
    */
   authorization<AuthRuleType extends Authorization<any, any, any>>(
     callback: (allow: AllowModifier) => AuthRuleType | AuthRuleType[],
-  ): ModelRelationalField<T, K | 'authorization', K, AuthRuleType>;
+  ): ModelRelationshipField<T, K | 'authorization', K, AuthRuleType>;
 };
 
-export type ModelRelationalField<
-  T extends ModelRelationalFieldParamShape,
-  // RM adds structural separation with ModelField; easier to identify it when mapping to ClientTypes
+/**
+ * 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 ModelRelationalField<T, RM> = never,
+  K extends keyof ModelRelationshipField<T, RM> = never,
   Auth = undefined,
-> = Omit<ModelRelationalFieldFunctions<T, RM, K>, K> & {
+> = Omit<ModelRelationshipFieldFunctions<T, RM, K>, K> & {
   // This is a lie. This property is never set at runtime. It's just used to smuggle auth types through.
   [__auth]?: Auth;
 } & Brand<typeof brandName>;
@@ -83,15 +92,15 @@ export type ModelRelationalField<
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.
  */
-export type InternalRelationalField = ModelRelationalField<
-  ModelRelationalFieldParamShape,
+export type InternalRelationshipField = ModelRelationshipField<
+  ModelRelationshipFieldParamShape,
   string,
   never
 > & {
-  data: ModelRelationalFieldData;
+  data: ModelRelationshipFieldData;
 };
 
-const relationalModifiers = [
+const relationshipModifiers = [
   'required',
   'valueRequired',
   'authorization',
@@ -99,7 +108,7 @@ const relationalModifiers = [
 
 const relationModifierMap: Record<
   `${ModelRelationshipTypes}`,
-  (typeof relationalModifiers)[number][]
+  (typeof relationshipModifiers)[number][]
 > = {
   belongsTo: ['authorization'],
   hasMany: ['valueRequired', 'authorization'],
@@ -116,12 +125,12 @@ export type RelationTypeFunctionOmitMapping<
       ? 'valueRequired'
       : never;
 
-function _modelRelationalField<
-  T extends ModelRelationalFieldParamShape,
+function _modelRelationshipField<
+  T extends ModelRelationshipFieldParamShape,
   RelatedModel extends string,
   RT extends ModelRelationshipTypes,
 >(type: RT, relatedModel: RelatedModel, references: string[]) {
-  const data: ModelRelationalFieldData = {
+  const data: ModelRelationshipFieldData = {
     relatedModel,
     type,
     fieldType: 'model',
@@ -150,7 +159,7 @@ function _modelRelationalField<
 
       return this;
     },
-  } as ModelRelationalField<T, RelatedModel>;
+  } as ModelRelationshipField<T, RelatedModel>;
 
   const builder = Object.fromEntries(
     relationModifierMap[type].map((key) => [
@@ -162,14 +171,21 @@ function _modelRelationalField<
   return {
     ...builder,
     data,
-  } as InternalRelationalField as ModelRelationalField<
+  } as InternalRelationshipField as ModelRelationshipField<
     T,
     RelatedModel,
     RelationTypeFunctionOmitMapping<typeof type>
   >;
 }
 
-export type ModelRelationalTypeArgFactory<
+/**
+ * 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,
@@ -212,8 +228,8 @@ export function hasOne<RM extends string>(
   relatedModel: RM,
   references: string | string[],
 ) {
-  return _modelRelationalField<
-    ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>,
+  return _modelRelationshipField<
+    ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>,
     RM,
     ModelRelationshipTypes.hasOne
   >(
@@ -235,7 +251,7 @@ export function hasOne<RM extends string>(
  *     team: a.belongsTo('Team', 'teamId'),
  *   })
  *   .authorization(allow => [allow.publicApiKey()]),
- * 
+ *
  *   Team: a.model({
  *     mantra: a.string().required(),
  *     // 3. Create a hasMany relationship with the reference field
@@ -253,8 +269,8 @@ export function hasMany<RM extends string>(
   relatedModel: RM,
   references: string | string[],
 ) {
-  return _modelRelationalField<
-    ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>,
+  return _modelRelationshipField<
+    ModelRelationshipTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>,
     RM,
     ModelRelationshipTypes.hasMany
   >(
@@ -268,8 +284,8 @@ export function hasMany<RM extends string>(
  * 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
  * parent to the related model.
- * 
- * @example 
+ *
+ * @example
  * // one-to-many relationship
  * const schema = a.schema({
  *   Member: a.model({
@@ -280,7 +296,7 @@ export function hasMany<RM extends string>(
  *     team: a.belongsTo('Team', 'teamId'),
  *   })
  *   .authorization(allow => [allow.publicApiKey()]),
- * 
+ *
  *   Team: a.model({
  *     mantra: a.string().required(),
  *     // 3. Create a hasMany relationship with the reference field
@@ -315,8 +331,12 @@ export function belongsTo<RM extends string>(
   relatedModel: RM,
   references: string | string[],
 ) {
-  return _modelRelationalField<
-    ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false>,
+  return _modelRelationshipField<
+    ModelRelationshipTypeArgFactory<
+      RM,
+      ModelRelationshipTypes.belongsTo,
+      false
+    >,
     RM,
     ModelRelationshipTypes.belongsTo
   >(

package/src/ModelSchema.ts

@@ -27,9 +27,9 @@ import { processSchema } from './SchemaProcessor';
 import { AllowModifier, SchemaAuthorization, allow } from './Authorization';
 import { Brand, brand, getBrand, RenameUsingTuples } from './util';
 import {
-  ModelRelationalField,
-  ModelRelationalFieldParamShape,
-} from './ModelRelationalField';
+  ModelRelationshipField,
+  ModelRelationshipFieldParamShape,
+} from './ModelRelationshipField';
 import { ConversationType } from './ai/ConversationType';
 
 export { ModelType } from './ModelType';
@@ -104,6 +104,12 @@ export type BaseSchema<
 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,
@@ -138,7 +144,7 @@ type OmitFromEach<Models, Modifier extends string> = {
 
 type RelationshipTemplate = Record<
   string,
-  ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>
+  ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>
 >;
 
 export type RDSModelSchema<
@@ -252,7 +258,7 @@ type ModelWithRelationships<
 > = ModelName extends keyof RelationshipMap
   ? RelationshipMap[ModelName] extends Record<
       string,
-      ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>
+      ModelRelationshipField<ModelRelationshipFieldParamShape, string, any, any>
     >
     ? AddRelationshipFieldsToModelTypeFields<
         Types[ModelName],
@@ -440,7 +446,11 @@ type SchemaReturnType<
   DE extends DatasourceEngine,
   Types extends ModelSchemaContents,
 > = DE extends 'dynamodb'
-  ? ModelSchema<{ types: Types; authorization: []; configuration: any }>
+  ? ModelSchema<{
+      types: Types;
+      authorization: [];
+      configuration: any;
+    }>
   : RDSModelSchema<{
       types: Types;
       authorization: [];