@aws-amplify/data-schema 0.13.6 → 0.13.8

package/lib-esm/src/CustomOperation.d.ts

@@ -5,14 +5,14 @@ import { Authorization } from './Authorization';
 import { RefType, InternalRef } from './RefType';
 import { EnumType, EnumTypeParamShape } from './EnumType';
 import { CustomType } from './CustomType';
-import { Handler } from './Handler';
+import type { HandlerType as Handler } from './Handler';
 type CustomArguments = Record<string, ModelField<any, any> | EnumType<EnumTypeParamShape>>;
 type CustomReturnType = RefType<any> | CustomType<any>;
 type CustomFunctionRefType = string;
 type InternalCustomArguments = Record<string, InternalField>;
 type InternalCustomReturnType = InternalRef;
+type HandlerInputType = Handler | Handler[number];
 declare const brandName = "customOperation";
-type HandlerInputType = Handler | Handler[];
 export declare const CustomOperationNames: readonly ["Query", "Mutation", "Subscription"];
 type CustomOperationName = (typeof CustomOperationNames)[number];
 type CustomData = {
@@ -21,7 +21,7 @@ type CustomData = {
     functionRef: string | null;
     authorization: Authorization<any, any, any>[];
     typeName: CustomOperationName;
-    handlers: Handler[] | null;
+    handlers: Handler | null;
 };
 type InternalCustomData = CustomData & {
     arguments: InternalCustomArguments;
@@ -35,14 +35,13 @@ export type CustomOperationParamShape = {
     functionRef: string | null;
     authorization: Authorization<any, any, any>[];
     typeName: CustomOperationName;
-    handlers: Handler[] | null;
 };
 export type CustomOperation<T extends CustomOperationParamShape, K extends keyof CustomOperation<T> = never> = Omit<{
     arguments<Arguments extends CustomArguments>(args: Arguments): CustomOperation<SetTypeSubArg<T, 'arguments', Arguments>, K | 'arguments'>;
     returns<ReturnType extends CustomReturnType>(returnType: ReturnType): CustomOperation<SetTypeSubArg<T, 'returnType', ReturnType>, K | 'returns'>;
     function<FunctionRef extends CustomFunctionRefType>(functionRefOrName: FunctionRef): CustomOperation<SetTypeSubArg<T, 'functionRef', FunctionRef>, K | 'function'>;
     authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): CustomOperation<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
-    handler(handlers: HandlerInputType): CustomOperation<SetTypeSubArg<T, 'handlers', Handler[]>, K | 'handler'>;
+    handler(handlers: HandlerInputType): CustomOperation<T, K | 'handler'>;
 }, K> & Brand<typeof brandName>;
 /**
  * Internal representation of Custom Type that exposes the `data` property.

package/lib-esm/src/CustomOperation.js

@@ -37,7 +37,9 @@ function _custom(typeName) {
             return this;
         },
         handler(handlers) {
-            data.handlers = Array.isArray(handlers) ? handlers : [handlers];
+            data.handlers = Array.isArray(handlers)
+                ? handlers
+                : [handlers];
             return this;
         },
     });

package/lib-esm/src/CustomType.d.ts

@@ -1,5 +1,7 @@
-import { Brand } from './util';
-import { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelField';
+import type { Brand } from './util';
+import type { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelField';
+import type { RefType } from './RefType';
+import type { EnumType, EnumTypeParamShape } from './EnumType';
 /**
  * Custom Types
  *
@@ -7,7 +9,7 @@ import { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelFiel
  *
  */
 export type CustomTypeAllowedModifiers = 'authorization' | 'array' | 'required';
-type CustomTypeFields = Record<string, ModelField<ModelFieldTypeParamOuter, CustomTypeAllowedModifiers, any>>;
+type CustomTypeFields = Record<string, ModelField<ModelFieldTypeParamOuter, CustomTypeAllowedModifiers, any> | RefType<any, any, any> | EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape>>;
 type InternalModelFields = Record<string, InternalField>;
 type CustomTypeData = {
     fields: CustomTypeFields;

package/lib-esm/src/Handler.d.ts

@@ -1,22 +1,47 @@
 import { Brand } from './util';
-declare const brandName = "Handler";
-export type Handler = Brand<typeof brandName>;
-type InlineSqlResult = {
-    sql: string;
-} & Handler;
-declare function inlineSql(sql: string): InlineSqlResult;
-type SqlReferenceResult = {
-    sqlReference: string;
-} & Handler;
-declare function sqlReference(sqlReference: string): SqlReferenceResult;
-type CustomResult = {
-    custom: string;
-} & Handler;
-declare function custom(file: string): CustomResult;
-type FunctionResult = {
-    function: (...args: any[]) => any;
-} & Handler;
-declare function fcn(fcn: (...args: any[]) => any): FunctionResult;
+import { RefType } from './RefType';
+export type HandlerType = InlineSqlHandler[] | SqlReferenceHandler[] | CustomHandler[] | FunctionHandler[];
+declare const dataSymbol: unique symbol;
+type AllHandlers = InlineSqlHandler | SqlReferenceHandler | CustomHandler | FunctionHandler;
+export declare function getHandlerData<H extends AllHandlers>(handler: H): H[typeof dataSymbol];
+declare const inlineSqlBrand = "inlineSql";
+export type InlineSqlHandler = {
+    [dataSymbol]: string;
+} & Brand<typeof inlineSqlBrand>;
+declare function inlineSql(sql: string): InlineSqlHandler;
+declare const sqlReferenceBrand = "sqlReference";
+export type SqlReferenceHandler = {
+    [dataSymbol]: string;
+} & Brand<typeof sqlReferenceBrand>;
+declare function sqlReference(sqlReference: string): SqlReferenceHandler;
+type CustomHandlerInput = {
+    /**
+     * The data source used by the function.
+     * Can reference a model in the schema with a.ref('ModelName') or any string data source name configured in your API
+     *
+     * Defaults to 'NONE_DS'
+     *
+     */
+    dataSource?: string | RefType<any, any, any>;
+    /**
+     * The path to the file that contains the function entry point.
+     * If this is a relative path, it is computed relative to the file where this handler is defined
+     */
+    entry: string;
+};
+export type CustomHandlerData = CustomHandlerInput & {
+    stack: string | undefined;
+};
+declare const customHandlerBrand = "customHandler";
+export type CustomHandler = {
+    [dataSymbol]: CustomHandlerData;
+} & Brand<typeof customHandlerBrand>;
+declare function custom(customHandler: CustomHandlerInput): CustomHandler;
+declare const functionHandlerBrand = "functionHandler";
+export type FunctionHandler = {
+    [dataSymbol]: (...args: any[]) => any;
+} & Brand<typeof functionHandlerBrand>;
+declare function fcn(fn: (...args: any[]) => any): FunctionHandler;
 export declare const handler: {
     inlineSql: typeof inlineSql;
     sqlReference: typeof sqlReference;

package/lib-esm/src/Handler.js

@@ -1,22 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = void 0;
+exports.handler = exports.getHandlerData = void 0;
 const util_1 = require("./util");
-const brandName = 'Handler';
-function buildHandler() {
+const dataSymbol = Symbol('Data');
+function buildHandler(brandName) {
     return (0, util_1.brand)(brandName);
 }
+function getHandlerData(handler) {
+    return handler[dataSymbol];
+}
+exports.getHandlerData = getHandlerData;
+const inlineSqlBrand = 'inlineSql';
 function inlineSql(sql) {
-    return { sql, ...buildHandler() };
+    return { [dataSymbol]: sql, ...buildHandler(inlineSqlBrand) };
 }
+const sqlReferenceBrand = 'sqlReference';
 function sqlReference(sqlReference) {
-    return { sqlReference, ...buildHandler() };
+    return { [dataSymbol]: sqlReference, ...buildHandler(sqlReferenceBrand) };
 }
-function custom(file) {
-    return { custom: file, ...buildHandler() };
+const customHandlerBrand = 'customHandler';
+function custom(customHandler) {
+    // used to determine caller directory in order to resolve relative path downstream
+    const stack = new Error().stack;
+    return {
+        [dataSymbol]: { ...customHandler, stack },
+        ...buildHandler(customHandlerBrand),
+    };
 }
-function fcn(fcn) {
-    return { function: fcn, ...buildHandler() };
+const functionHandlerBrand = 'functionHandler';
+function fcn(fn) {
+    return { [dataSymbol]: fn, ...buildHandler(functionHandlerBrand) };
 }
 exports.handler = {
     inlineSql,

package/lib-esm/src/MappedTypes/ExtractNonModelTypes.d.ts

@@ -1,21 +1,63 @@
 import type { UnionToIntersection } from '@aws-amplify/data-schema-types';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
 import type { EnumType, EnumTypeParamShape } from '../EnumType';
-import type { SchemaTypes, ModelTypes } from './ResolveSchema';
-import type { ModelField } from '../ModelField';
+import type { SchemaTypes, ModelAndCustomTypes, FieldTypesOfCustomType } from './ResolveSchema';
+import type { ModelType, ModelTypeParamShape } from '../ModelType';
 export type NonModelTypesShape = {
     enums: Record<string, EnumType<any>>;
     customTypes: Record<string, any>;
 };
 export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModelTypes<Schema, ExtractImplicitNonModelTypes<Schema>>>;
 /**
- * Pulls out implicit, i.e. field-level non-model types from Schema
+ * Extract all implicit non-model types a `FieldName: Field` map recursively,
+ * and store them in a flat map. The keys are serialized property path.
+ *
+ * For example, with the following schema structure:
+ * ```
+ * ExtractAndFlattenImplicitNonModelTypesFromFields<
+ *   'Post',
+ *   {
+ *     content: string,
+ *     status: enum(['reviewing'], ['published']),
+ *     meta: customType({
+ *       tag: enum(['internal', 'external']),
+ *       views: number
+ *     }),
+ *     tag: ref('SomeExplicitEnum'),
+ *   }
+ * >
+ * ```
+ * It generates the result as:
+ * ```
+ * {
+ *   PostStatus: enum(['reviewing'], ['published']),
+ *   PostMeta: customType({
+ *     tag: enum(['internal', 'external']),
+ *     views: number
+ *   }),
+ *   PostMetaTag: enum(['internal', 'external']),
+ * }
+ * ```
  */
-type ExtractImplicitNonModelTypes<Schema, ResolvedModels = ModelTypes<SchemaTypes<Schema>>> = UnionToIntersection<{
-    [Model in keyof ResolvedModels]: {
-        [Field in keyof ResolvedModels[Model] as ResolvedModels[Model][Field] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? `${Capitalize<Model & string>}${Capitalize<Field & string>}` : never]: ResolvedModels[Model][Field];
-    };
-}[keyof ResolvedModels]>;
+export type ExtractAndFlattenImplicitNonModelTypesFromFields<ParentTypeName extends string, Fields> = {
+    [FieldProp in keyof Fields as Fields[FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? FieldProp : never]: (x: NonNullable<Fields[FieldProp]> extends infer FieldType ? FieldType extends EnumType<EnumTypeParamShape> ? {
+        [Key in `${ParentTypeName}${Capitalize<FieldProp & string>}`]: Fields[FieldProp];
+    } : FieldType extends CustomType<infer CustomTypeShape extends CustomTypeParamShape> ? // recursively extract to the Nested CustomType, and return the
+    ExtractAndFlattenImplicitNonModelTypesFromFields<`${ParentTypeName}${Capitalize<FieldProp & string>}`, CustomTypeShape['fields']> & {
+        [Key in `${ParentTypeName}${Capitalize<FieldProp & string>}`]: Fields[FieldProp];
+    } : never : never) => void;
+} extends Record<string, infer Func> ? Func extends (x: infer P) => void ? P : Record<never, never> : Record<never, never>;
+/**
+ * Pulls out implicit, i.e. field-level non-model types from `ModelType` and
+ * `CustomType` which may contain deeply nested implicit (inline) non-model
+ * types.
+ */
+export type ExtractImplicitNonModelTypes<Schema, Targets = ModelAndCustomTypes<SchemaTypes<Schema>>> = UnionToIntersection<{
+    [Model in keyof Targets]: Targets[Model] extends CustomType<infer R extends CustomTypeParamShape> ? // extract nested non-model types from it, and include itself
+    ExtractAndFlattenImplicitNonModelTypesFromFields<Capitalize<Model & string>, R['fields']> & {
+        [key in Model]: Targets[Model];
+    } : Targets[Model] extends ModelType<infer R extends ModelTypeParamShape, any> ? ExtractAndFlattenImplicitNonModelTypesFromFields<Capitalize<Model & string>, R['fields']> : Targets[Model];
+}[keyof Targets]>;
 type ResolveNonModelTypes<Schema, Extracted, ResolvedSchema = SchemaTypes<Schema> & Extracted> = {
     enums: {
         [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType<EnumTypeParamShape> ? Model : never]: ResolvedSchema[Model] extends EnumType<infer R extends EnumTypeParamShape> ? R['values'][number] : never;
@@ -26,10 +68,6 @@ type ResolveNonModelTypes<Schema, Extracted, ResolvedSchema = SchemaTypes<Schema
 };
 type ResolveNonModelFields<T extends NonModelTypesShape> = {
     enums: T['enums'];
-    customTypes: {
-        [CustomType in keyof T['customTypes']]: {
-            [FieldProp in keyof T['customTypes'][CustomType]]: T['customTypes'][CustomType][FieldProp] extends ModelField<infer R, any, any> ? R : never;
-        };
-    };
+    customTypes: FieldTypesOfCustomType<T['customTypes']>;
 };
 export {};

package/lib-esm/src/MappedTypes/ResolveFieldProperties.d.ts

@@ -15,7 +15,7 @@ import type { EnumType, EnumTypeParamShape } from '../EnumType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 export type ResolveFieldProperties<Schema extends ModelSchema<any, any>, NonModelTypes extends NonModelTypesShape, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, {
     identifier: string;
-}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedModels = InjectImplicitModels<ResolvedSchema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<FieldsWithInjectedModels, IdentifierMeta>, FieldsWithRelationships = ResolveRelationships<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<RequiredFieldTypes<FieldsWithRelationships>>, FilterFieldTypes<OptionalFieldTypes<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>, AllImpliedFKs<ResolvedSchema, IdentifierMeta>>;
+}> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedModels = InjectImplicitModels<ResolvedSchema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<FieldsWithInjectedModels, IdentifierMeta>, FieldsWithRelationships = ResolveRelationships<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>, AllImpliedFKs<ResolvedSchema, IdentifierMeta>>;
 type ExtractImplicitModelNames<Schema> = UnionToIntersection<ExcludeEmpty<{
     [ModelProp in keyof Schema]: {
         [FieldProp in keyof Schema[ModelProp] as Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relationName'] extends string ? Schema[ModelProp][FieldProp]['relationName'] extends keyof Schema ? never : Schema[ModelProp][FieldProp]['relationName'] : never : never]: {
@@ -28,7 +28,10 @@ type GetRelationshipRef<T, RM extends keyof T, TypeArg extends ModelRelationalFi
 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];
 };
-export type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], Value = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? NonModelTypes['customTypes'][Link] : never> = Ref['required'] extends true ? Value : Value | null;
+export type ResolveRef<NonModelTypes extends NonModelTypesShape, Ref extends RefTypeParamShape, Link extends string = Ref['link'], Value = Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never> = Ref['required'] extends true ? Value : Value | null;
+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 ? ExtractNullableFieldsToOptionalFields<Resolved> & ExtractNonNullableFieldsToRequiredFields<Resolved> : never;
 type ResolveRelationships<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 ? Schema[ModelProp][FieldProp]['relationshipType'] extends 'manyToMany' ? Schema[ModelProp][FieldProp]['relationName'] extends keyof Schema ? GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relationName'], Schema[ModelProp][FieldProp], Flat> : never : GetRelationshipRef<Schema, Schema[ModelProp][FieldProp]['relatedModel'], Schema[ModelProp][FieldProp], Flat> : never : Schema[ModelProp][FieldProp];
@@ -39,15 +42,17 @@ type FilterFieldTypes<Schema> = {
         [FieldProp in keyof Schema[ModelProp] as Schema[ModelProp][FieldProp] extends undefined ? never : FieldProp]: Schema[ModelProp][FieldProp];
     };
 };
-type OptionalFieldTypes<Schema> = {
-    [ModelProp in keyof Schema]: Partial<{
-        [FieldProp in keyof Schema[ModelProp]]: null extends Schema[ModelProp][FieldProp] ? Schema[ModelProp][FieldProp] : never;
-    }>;
+type ExtractNullableFieldsToOptionalFields<Fields> = Partial<{
+    [FieldProp in keyof Fields as null extends Fields[FieldProp] ? FieldProp : never]: null extends Fields[FieldProp] ? Fields[FieldProp] : never;
+}>;
+type MarkModelsNullableFieldsOptional<Schema> = {
+    [ModelProp in keyof Schema]: ExtractNullableFieldsToOptionalFields<Schema[ModelProp]>;
 };
-type RequiredFieldTypes<Schema> = {
-    [ModelProp in keyof Schema]: {
-        [FieldProp in keyof Schema[ModelProp]]: null extends Schema[ModelProp][FieldProp] ? never : Schema[ModelProp][FieldProp];
-    };
+type ExtractNonNullableFieldsToRequiredFields<Fields> = {
+    [FieldProp in keyof Fields as null extends Fields[FieldProp] ? never : FieldProp]: null extends Fields[FieldProp] ? never : Fields[FieldProp];
+};
+type MarkModelsNonNullableFieldsRequired<Schema> = {
+    [ModelProp in keyof Schema]: ExtractNonNullableFieldsToRequiredFields<Schema[ModelProp]>;
 };
 type Intersection<A, B, C, D> = A & B & C & D extends infer U ? {
     [P in keyof U]: U[P];

package/lib-esm/src/MappedTypes/ResolveSchema.d.ts

@@ -18,6 +18,13 @@ export type SchemaTypes<T> = T extends ModelSchema<any, any> ? T['data']['types'
 export type ModelTypes<Schema> = {
     [Model in keyof Schema as Schema[Model] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<infer R, any> ? R['fields'] : never;
 };
+/**
+ * Gets the collection of all ModelTypes and CustomTypes which are explicitly
+ * defined in the schema.
+ */
+export type ModelAndCustomTypes<Schema> = {
+    [Model in keyof Schema as Schema[Model] extends EnumType<EnumTypeParamShape> | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<any, any> ? Schema[Model] : Schema[Model] extends CustomType<CustomTypeParamShape> ? Schema[Model] : never;
+};
 /**
  * Resolves field types
  *
@@ -25,11 +32,29 @@ export type ModelTypes<Schema> = {
  */
 export type FieldTypes<T> = {
     [ModelProp in keyof T]: {
-        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['required'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+        [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<infer R, any, any> ? R : T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['required'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<ModelProp & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
             required: false;
             authorization: [];
-        }> | null : T[ModelProp][FieldProp] extends ModelRelationalField<infer R, string, RelationTypeFunctionOmitMapping<ModelRelationshipTypes>, any> ? R : T[ModelProp][FieldProp] extends ModelField<infer R, any, any> ? R : never;
+        }> | null : T[ModelProp][FieldProp] extends ModelRelationalField<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.
+ *
+ * Non-model types are replaced with Refs. Refs remain and are resolved in ResolveFieldProperties.ts
+ */
+export type FieldTypesOfCustomType<T> = {
+    [CustomTypeName in keyof T]: {
+        [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends ModelField<infer R, any, any> ? R : T[CustomTypeName][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['required'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+            link: `${Capitalize<CustomTypeName & string>}${Capitalize<FieldProp & string>}`;
+            type: 'ref';
+            required: false;
+            authorization: [];
+        }> | null : never;
     };
 };

package/lib-esm/src/SchemaProcessor.d.ts

@@ -1,5 +1,5 @@
 import type { InternalSchema } from './ModelSchema';
-import { DerivedApiDefinition } from './types';
+import { DerivedApiDefinition } from '@aws-amplify/data-schema-types';
 /**
  * Returns API definition from ModelSchema or string schema
  * @param arg - { schema }