@aws-amplify/data-schema 1.1.4 → 1.1.6

package/dist/esm/CustomType.d.ts

@@ -1,7 +1,7 @@
 import type { Brand } from './util';
-import type { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelField';
+import type { InternalField, BaseModelField } from './ModelField';
 import type { RefType } from './RefType';
-import type { EnumType, EnumTypeParamShape } from './EnumType';
+import type { EnumType } from './EnumType';
 /**
  * Custom Types
  *
@@ -9,7 +9,7 @@ import type { EnumType, EnumTypeParamShape } from './EnumType';
  *
  */
 export type CustomTypeAllowedModifiers = 'authorization' | 'array' | 'required';
-type CustomTypeFields = Record<string, ModelField<ModelFieldTypeParamOuter, CustomTypeAllowedModifiers, any> | RefType<any, any, any> | EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape>>;
+type CustomTypeFields = Record<string, BaseModelField | RefType<any, any, any> | EnumType | CustomType<CustomTypeParamShape>>;
 type InternalModelFields = Record<string, InternalField>;
 type CustomTypeData = {
     fields: CustomTypeFields;
@@ -29,6 +29,38 @@ export type CustomType<T extends CustomTypeParamShape> = T & Brand<'customType'>
 export type InternalCustomType = CustomType<any> & {
     data: InternalCustomTypeData;
 };
+/**
+ * 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
+ * @example
+ * a.schema({
+ *   Post: a.model({
+ *     location: a.customType({
+ *       lat: a.float(),
+ *       long: a.float(),
+ *     }),
+ *     content: a.string(),
+ *   }),
+ * });
+ * @example
+ * a.schema({
+ *   Location: a.customType({
+ *       lat: a.float(),
+ *       long: a.float(),
+ *   }),
+ *
+ *   Post: a.model({
+ *     location: a.ref('Location'),
+ *     content: a.string(),
+ *   }),
+ *
+ *   User: a.model({
+ *     lastKnownLocation: a.ref('Location'),
+ *   }),
+ * });
+ */
 export declare function customType<T extends CustomTypeFields>(fields: T): CustomType<{
     fields: T;
 }>;

package/dist/esm/CustomType.mjs

@@ -5,6 +5,38 @@ function _customType(fields) {
     };
     return { data };
 }
+/**
+ * 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
+ * @example
+ * a.schema({
+ *   Post: a.model({
+ *     location: a.customType({
+ *       lat: a.float(),
+ *       long: a.float(),
+ *     }),
+ *     content: a.string(),
+ *   }),
+ * });
+ * @example
+ * a.schema({
+ *   Location: a.customType({
+ *       lat: a.float(),
+ *       long: a.float(),
+ *   }),
+ *
+ *   Post: a.model({
+ *     location: a.ref('Location'),
+ *     content: a.string(),
+ *   }),
+ *
+ *   User: a.model({
+ *     lastKnownLocation: a.ref('Location'),
+ *   }),
+ * });
+ */
 function customType(fields) {
     return _customType(fields);
 }

package/dist/esm/CustomType.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"CustomType.mjs","sources":["../../src/CustomType.ts"],"sourcesContent":["function _customType(fields) {\n    const data = {\n        fields,\n        type: 'customType',\n    };\n    return { data };\n}\nexport function customType(fields) {\n    return _customType(fields);\n}\n"],"names":[],"mappings":"AAAA,SAAS,WAAW,CAAC,MAAM,EAAE;AAC7B,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,MAAM;AACd,QAAQ,IAAI,EAAE,YAAY;AAC1B,KAAK,CAAC;AACN,IAAI,OAAO,EAAE,IAAI,EAAE,CAAC;AACpB,CAAC;AACM,SAAS,UAAU,CAAC,MAAM,EAAE;AACnC,IAAI,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC;AAC/B;;;;"}
+{"version":3,"file":"CustomType.mjs","sources":["../../src/CustomType.ts"],"sourcesContent":["function _customType(fields) {\n    const data = {\n        fields,\n        type: 'customType',\n    };\n    return { data };\n}\n/**\n * Define a custom type. This type represents an inline, typed JSON object.\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/add-fields/#specify-a-custom-field-type}\n * @param fields the fields to be added to the custom type\n * @returns a custom type\n * @example\n * a.schema({\n *   Post: a.model({\n *     location: a.customType({\n *       lat: a.float(),\n *       long: a.float(),\n *     }),\n *     content: a.string(),\n *   }),\n * });\n * @example\n * a.schema({\n *   Location: a.customType({\n *       lat: a.float(),\n *       long: a.float(),\n *   }),\n *\n *   Post: a.model({\n *     location: a.ref('Location'),\n *     content: a.string(),\n *   }),\n *\n *   User: a.model({\n *     lastKnownLocation: a.ref('Location'),\n *   }),\n * });\n */\nexport function customType(fields) {\n    return _customType(fields);\n}\n"],"names":[],"mappings":"AAAA,SAAS,WAAW,CAAC,MAAM,EAAE;AAC7B,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,MAAM;AACd,QAAQ,IAAI,EAAE,YAAY;AAC1B,KAAK,CAAC;AACN,IAAI,OAAO,EAAE,IAAI,EAAE,CAAC;AACpB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,UAAU,CAAC,MAAM,EAAE;AACnC,IAAI,OAAO,WAAW,CAAC,MAAM,CAAC,CAAC;AAC/B;;;;"}

package/dist/esm/EnumType.d.ts

@@ -1,15 +1,13 @@
-import { Brand } from './util';
-export type EnumTypeParamShape = {
+import type { brandSymbol } from './util/Brand.js';
+type EnumTypeParamShape<values extends readonly string[] = readonly string[]> = {
     type: 'enum';
-    values: readonly string[];
-};
-export type EnumType<T extends EnumTypeParamShape> = T & Brand<'enum'>;
-type EnumTypeArgFactory<Values extends readonly string[]> = {
-    type: 'enum';
-    values: Values;
+    values: values;
 };
+export interface EnumType<values extends readonly string[] = readonly string[]> extends EnumTypeParamShape<values> {
+    [brandSymbol]: 'enum';
+}
 /**
  * this type param pattern allows us to infer literal type values from the array without using the `as const` suffix
  */
-export declare function enumType<Value extends string, T extends readonly Value[]>(values: T): EnumType<EnumTypeArgFactory<T>>;
+export declare function enumType<const values extends readonly string[]>(values: values): EnumType<values>;
 export {};

package/dist/esm/Handler.d.ts

@@ -41,12 +41,74 @@ declare const customHandlerBrand = "customHandler";
 export type CustomHandler = {
     [dataSymbol]: CustomHandlerData;
 } & Brand<typeof customHandlerBrand>;
+/**
+ * Use a custom JavaScript resolver to handle a query, mutation, or subscription.
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/#step-2---configure-custom-business-logic-handler-code}
+ * @param customHandler `{ entry: "path-to-javascript-resolver-file.js", dataSource: "Data Source name added via "backend.data.add*DataSoruce(...)"}`
+ * @returns A JavaScript resolver attached to the query, mutation, or subscription.
+ * @example
+ * const schema = a.schema({
+ *   Post: a.model({
+ *     content: a.string(),
+ *     likes: a.integer()
+ *       .authorization(allow => [allow.authenticated().to(['read'])])
+ *   }).authorization(allow => [
+ *     allow.owner(),
+ *     allow.authenticated().to(['read'])
+ *   ]),
+ *
+ *   likePost: a
+ *     .mutation()
+ *     .arguments({ postId: a.id() })
+ *     .returns(a.ref('Post'))
+ *     .authorization(allow => [allow.authenticated()])
+ *     .handler(a.handler.custom({
+ *       dataSource: a.ref('Post'),
+ *       entry: './increment-like.js'
+ *     }))
+ * });
+ */
 declare function custom(customHandler: CustomHandlerInput): CustomHandler;
 export type FunctionHandlerData = DefineFunction | string;
 declare const functionHandlerBrand = "functionHandler";
 export type FunctionHandler = {
     [dataSymbol]: FunctionHandlerData;
 } & Brand<typeof functionHandlerBrand>;
+/**
+ * Use a function created via `defineFunction` to handle the custom query/mutation/subscription. In your function handler,
+ * you can use the `Schema["YOUR_QUERY_OR_MUTATION_NAME"]["functionHandler"]` utility type to type the handler function.
+ * @example
+ * import {
+ *   type ClientSchema,
+ *   a,
+ *   defineData,
+ *   defineFunction // 1.Import "defineFunction" to create new functions
+ * } from '@aws-amplify/backend';
+ *
+ * // 2. define a function
+ * const echoHandler = defineFunction({
+ *   entry: './echo-handler/handler.ts'
+ * })
+ *
+ * const schema = a.schema({
+ *   EchoResponse: a.customType({
+ *     content: a.string(),
+ *     executionDuration: a.float()
+ *   }),
+ *
+ *   echo: a
+ *     .query()
+ *     .arguments({ content: a.string() })
+ *     .returns(a.ref('EchoResponse'))
+ *     .authorization(allow => [allow.publicApiKey()])
+ *     // 3. set the function has the handler
+ *     .handler(a.handler.function(echoHandler))
+ * });
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/}
+ * @param fn A function created via `defineFunction`. Alternatively, you can pass in a "string" of the function name and pass
+ * in a corresponding value into the `functionMap` property of defineData.
+ * @returns A handler for the query / mutation / subscription
+ */
 declare function fcn(fn: FunctionHandlerData): FunctionHandler;
 export declare const handler: {
     inlineSql: typeof inlineSql;

package/dist/esm/Handler.mjs

@@ -24,6 +24,33 @@ function sqlReference(sqlFilePath) {
     };
 }
 const customHandlerBrand = 'customHandler';
+/**
+ * Use a custom JavaScript resolver to handle a query, mutation, or subscription.
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/#step-2---configure-custom-business-logic-handler-code}
+ * @param customHandler `{ entry: "path-to-javascript-resolver-file.js", dataSource: "Data Source name added via "backend.data.add*DataSoruce(...)"}`
+ * @returns A JavaScript resolver attached to the query, mutation, or subscription.
+ * @example
+ * const schema = a.schema({
+ *   Post: a.model({
+ *     content: a.string(),
+ *     likes: a.integer()
+ *       .authorization(allow => [allow.authenticated().to(['read'])])
+ *   }).authorization(allow => [
+ *     allow.owner(),
+ *     allow.authenticated().to(['read'])
+ *   ]),
+ *
+ *   likePost: a
+ *     .mutation()
+ *     .arguments({ postId: a.id() })
+ *     .returns(a.ref('Post'))
+ *     .authorization(allow => [allow.authenticated()])
+ *     .handler(a.handler.custom({
+ *       dataSource: a.ref('Post'),
+ *       entry: './increment-like.js'
+ *     }))
+ * });
+ */
 function custom(customHandler) {
     // used to determine caller directory in order to resolve relative path downstream
     const stack = new Error().stack;
@@ -33,6 +60,41 @@ function custom(customHandler) {
     };
 }
 const functionHandlerBrand = 'functionHandler';
+/**
+ * Use a function created via `defineFunction` to handle the custom query/mutation/subscription. In your function handler,
+ * you can use the `Schema["YOUR_QUERY_OR_MUTATION_NAME"]["functionHandler"]` utility type to type the handler function.
+ * @example
+ * import {
+ *   type ClientSchema,
+ *   a,
+ *   defineData,
+ *   defineFunction // 1.Import "defineFunction" to create new functions
+ * } from '@aws-amplify/backend';
+ *
+ * // 2. define a function
+ * const echoHandler = defineFunction({
+ *   entry: './echo-handler/handler.ts'
+ * })
+ *
+ * const schema = a.schema({
+ *   EchoResponse: a.customType({
+ *     content: a.string(),
+ *     executionDuration: a.float()
+ *   }),
+ *
+ *   echo: a
+ *     .query()
+ *     .arguments({ content: a.string() })
+ *     .returns(a.ref('EchoResponse'))
+ *     .authorization(allow => [allow.publicApiKey()])
+ *     // 3. set the function has the handler
+ *     .handler(a.handler.function(echoHandler))
+ * });
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/}
+ * @param fn A function created via `defineFunction`. Alternatively, you can pass in a "string" of the function name and pass
+ * in a corresponding value into the `functionMap` property of defineData.
+ * @returns A handler for the query / mutation / subscription
+ */
 function fcn(fn) {
     return { [dataSymbol]: fn, ...buildHandler(functionHandlerBrand) };
 }

package/dist/esm/Handler.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"Handler.mjs","sources":["../../src/Handler.ts"],"sourcesContent":["import { brand } from './util';\nconst dataSymbol = Symbol('Data');\nfunction buildHandler(brandName) {\n    return brand(brandName);\n}\nexport function getHandlerData(handler) {\n    return handler[dataSymbol];\n}\n//#region handler.inlineSql\nconst inlineSqlBrand = 'inlineSql';\nfunction inlineSql(sql) {\n    return { [dataSymbol]: sql, ...buildHandler(inlineSqlBrand) };\n}\n//#endregion\n//#region handler.sqlReference\nconst sqlReferenceBrand = 'sqlReference';\nfunction sqlReference(sqlFilePath) {\n    // used to determine caller directory in order to resolve relative path downstream\n    const stack = new Error().stack;\n    return {\n        [dataSymbol]: { stack, entry: sqlFilePath },\n        ...buildHandler(sqlReferenceBrand),\n    };\n}\nconst customHandlerBrand = 'customHandler';\nfunction custom(customHandler) {\n    // used to determine caller directory in order to resolve relative path downstream\n    const stack = new Error().stack;\n    return {\n        [dataSymbol]: { ...customHandler, stack },\n        ...buildHandler(customHandlerBrand),\n    };\n}\nconst functionHandlerBrand = 'functionHandler';\nfunction fcn(fn) {\n    return { [dataSymbol]: fn, ...buildHandler(functionHandlerBrand) };\n}\n//#endregion\nexport const handler = {\n    inlineSql,\n    sqlReference,\n    custom,\n    function: fcn,\n};\n"],"names":[],"mappings":";;AACA,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AAClC,SAAS,YAAY,CAAC,SAAS,EAAE;AACjC,IAAI,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC;AAC5B,CAAC;AACM,SAAS,cAAc,CAAC,OAAO,EAAE;AACxC,IAAI,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;AAC/B,CAAC;AACD;AACA,MAAM,cAAc,GAAG,WAAW,CAAC;AACnC,SAAS,SAAS,CAAC,GAAG,EAAE;AACxB,IAAI,OAAO,EAAE,CAAC,UAAU,GAAG,GAAG,EAAE,GAAG,YAAY,CAAC,cAAc,CAAC,EAAE,CAAC;AAClE,CAAC;AACD;AACA;AACA,MAAM,iBAAiB,GAAG,cAAc,CAAC;AACzC,SAAS,YAAY,CAAC,WAAW,EAAE;AACnC;AACA,IAAI,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC,KAAK,CAAC;AACpC,IAAI,OAAO;AACX,QAAQ,CAAC,UAAU,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE;AACnD,QAAQ,GAAG,YAAY,CAAC,iBAAiB,CAAC;AAC1C,KAAK,CAAC;AACN,CAAC;AACD,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAC3C,SAAS,MAAM,CAAC,aAAa,EAAE;AAC/B;AACA,IAAI,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC,KAAK,CAAC;AACpC,IAAI,OAAO;AACX,QAAQ,CAAC,UAAU,GAAG,EAAE,GAAG,aAAa,EAAE,KAAK,EAAE;AACjD,QAAQ,GAAG,YAAY,CAAC,kBAAkB,CAAC;AAC3C,KAAK,CAAC;AACN,CAAC;AACD,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAC/C,SAAS,GAAG,CAAC,EAAE,EAAE;AACjB,IAAI,OAAO,EAAE,CAAC,UAAU,GAAG,EAAE,EAAE,GAAG,YAAY,CAAC,oBAAoB,CAAC,EAAE,CAAC;AACvE,CAAC;AACD;AACY,MAAC,OAAO,GAAG;AACvB,IAAI,SAAS;AACb,IAAI,YAAY;AAChB,IAAI,MAAM;AACV,IAAI,QAAQ,EAAE,GAAG;AACjB;;;;"}
+{"version":3,"file":"Handler.mjs","sources":["../../src/Handler.ts"],"sourcesContent":["import { brand } from './util';\nconst dataSymbol = Symbol('Data');\nfunction buildHandler(brandName) {\n    return brand(brandName);\n}\nexport function getHandlerData(handler) {\n    return handler[dataSymbol];\n}\n//#region handler.inlineSql\nconst inlineSqlBrand = 'inlineSql';\nfunction inlineSql(sql) {\n    return { [dataSymbol]: sql, ...buildHandler(inlineSqlBrand) };\n}\n//#endregion\n//#region handler.sqlReference\nconst sqlReferenceBrand = 'sqlReference';\nfunction sqlReference(sqlFilePath) {\n    // used to determine caller directory in order to resolve relative path downstream\n    const stack = new Error().stack;\n    return {\n        [dataSymbol]: { stack, entry: sqlFilePath },\n        ...buildHandler(sqlReferenceBrand),\n    };\n}\nconst customHandlerBrand = 'customHandler';\n/**\n * Use a custom JavaScript resolver to handle a query, mutation, or subscription.\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/#step-2---configure-custom-business-logic-handler-code}\n * @param customHandler `{ entry: \"path-to-javascript-resolver-file.js\", dataSource: \"Data Source name added via \"backend.data.add*DataSoruce(...)\"}`\n * @returns A JavaScript resolver attached to the query, mutation, or subscription.\n * @example\n * const schema = a.schema({\n *   Post: a.model({\n *     content: a.string(),\n *     likes: a.integer()\n *       .authorization(allow => [allow.authenticated().to(['read'])])\n *   }).authorization(allow => [\n *     allow.owner(),\n *     allow.authenticated().to(['read'])\n *   ]),\n *\n *   likePost: a\n *     .mutation()\n *     .arguments({ postId: a.id() })\n *     .returns(a.ref('Post'))\n *     .authorization(allow => [allow.authenticated()])\n *     .handler(a.handler.custom({\n *       dataSource: a.ref('Post'),\n *       entry: './increment-like.js'\n *     }))\n * });\n */\nfunction custom(customHandler) {\n    // used to determine caller directory in order to resolve relative path downstream\n    const stack = new Error().stack;\n    return {\n        [dataSymbol]: { ...customHandler, stack },\n        ...buildHandler(customHandlerBrand),\n    };\n}\nconst functionHandlerBrand = 'functionHandler';\n/**\n * Use a function created via `defineFunction` to handle the custom query/mutation/subscription. In your function handler,\n * you can use the `Schema[\"YOUR_QUERY_OR_MUTATION_NAME\"][\"functionHandler\"]` utility type to type the handler function.\n * @example\n * import {\n *   type ClientSchema,\n *   a,\n *   defineData,\n *   defineFunction // 1.Import \"defineFunction\" to create new functions\n * } from '@aws-amplify/backend';\n *\n * // 2. define a function\n * const echoHandler = defineFunction({\n *   entry: './echo-handler/handler.ts'\n * })\n *\n * const schema = a.schema({\n *   EchoResponse: a.customType({\n *     content: a.string(),\n *     executionDuration: a.float()\n *   }),\n *\n *   echo: a\n *     .query()\n *     .arguments({ content: a.string() })\n *     .returns(a.ref('EchoResponse'))\n *     .authorization(allow => [allow.publicApiKey()])\n *     // 3. set the function has the handler\n *     .handler(a.handler.function(echoHandler))\n * });\n * @see {@link https://docs.amplify.aws/react/build-a-backend/data/custom-business-logic/}\n * @param fn A function created via `defineFunction`. Alternatively, you can pass in a \"string\" of the function name and pass\n * in a corresponding value into the `functionMap` property of defineData.\n * @returns A handler for the query / mutation / subscription\n */\nfunction fcn(fn) {\n    return { [dataSymbol]: fn, ...buildHandler(functionHandlerBrand) };\n}\n//#endregion\nexport const handler = {\n    inlineSql,\n    sqlReference,\n    custom,\n    function: fcn,\n};\n"],"names":[],"mappings":";;AACA,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AAClC,SAAS,YAAY,CAAC,SAAS,EAAE;AACjC,IAAI,OAAO,KAAK,CAAC,SAAS,CAAC,CAAC;AAC5B,CAAC;AACM,SAAS,cAAc,CAAC,OAAO,EAAE;AACxC,IAAI,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC;AAC/B,CAAC;AACD;AACA,MAAM,cAAc,GAAG,WAAW,CAAC;AACnC,SAAS,SAAS,CAAC,GAAG,EAAE;AACxB,IAAI,OAAO,EAAE,CAAC,UAAU,GAAG,GAAG,EAAE,GAAG,YAAY,CAAC,cAAc,CAAC,EAAE,CAAC;AAClE,CAAC;AACD;AACA;AACA,MAAM,iBAAiB,GAAG,cAAc,CAAC;AACzC,SAAS,YAAY,CAAC,WAAW,EAAE;AACnC;AACA,IAAI,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC,KAAK,CAAC;AACpC,IAAI,OAAO;AACX,QAAQ,CAAC,UAAU,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE;AACnD,QAAQ,GAAG,YAAY,CAAC,iBAAiB,CAAC;AAC1C,KAAK,CAAC;AACN,CAAC;AACD,MAAM,kBAAkB,GAAG,eAAe,CAAC;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,MAAM,CAAC,aAAa,EAAE;AAC/B;AACA,IAAI,MAAM,KAAK,GAAG,IAAI,KAAK,EAAE,CAAC,KAAK,CAAC;AACpC,IAAI,OAAO;AACX,QAAQ,CAAC,UAAU,GAAG,EAAE,GAAG,aAAa,EAAE,KAAK,EAAE;AACjD,QAAQ,GAAG,YAAY,CAAC,kBAAkB,CAAC;AAC3C,KAAK,CAAC;AACN,CAAC;AACD,MAAM,oBAAoB,GAAG,iBAAiB,CAAC;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,GAAG,CAAC,EAAE,EAAE;AACjB,IAAI,OAAO,EAAE,CAAC,UAAU,GAAG,EAAE,EAAE,GAAG,YAAY,CAAC,oBAAoB,CAAC,EAAE,CAAC;AACvE,CAAC;AACD;AACY,MAAC,OAAO,GAAG;AACvB,IAAI,SAAS;AACb,IAAI,YAAY;AAChB,IAAI,MAAM;AACV,IAAI,QAAQ,EAAE,GAAG;AACjB;;;;"}

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

@@ -1,7 +1,7 @@
 import type { GenericModelSchema } from '../ModelSchema';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
-import type { ModelField } from '../ModelField';
+import type { BaseModelField } from '../ModelField';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { ResolveFieldRequirements, ResolveRefsOfCustomType, ResolveRefValueArrayTraits } from './ResolveFieldProperties';
 import type { AppSyncResolverHandler } from 'aws-lambda';
@@ -30,14 +30,14 @@ export type CustomOpShapes<Schema extends GenericModelSchema<any>> = {
  * Digs out custom operation arguments, mapped to the intended graphql types.
  */
 export type CustomOpArguments<Shape extends CustomOperationParamShape> = Shape['arguments'] extends null ? never : ResolveFieldRequirements<{
-    [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends ModelField<infer R, any, any> ? R : never;
+    [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends BaseModelField<infer R> ? R : never;
 }>;
 /**
  * Computes the return type from the `returnType` of a custom operation shape.
  *
  * This entails dereferencing refs and inferring graphql types from field-type defs.
  */
-export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, CustomOperations extends Record<string, CustomOperationParamShape>> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? RefShape['link'] extends keyof CustomOperations ? CustomOpReturnType<CustomOperations[RefShape['link']], FullyResolvedSchema, NonModelTypes, CustomOperations> : ResolveRef<RefShape, FullyResolvedSchema, NonModelTypes, CustomOperations> : Shape['returnType'] extends ModelField<infer R, any, any> ? R : Shape['returnType'] extends CustomType<infer R> ? ResolveFieldRequirements<FieldTypesOfCustomType<{
+export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, CustomOperations extends Record<string, CustomOperationParamShape>> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? RefShape['link'] extends keyof CustomOperations ? CustomOpReturnType<CustomOperations[RefShape['link']], FullyResolvedSchema, NonModelTypes, CustomOperations> : ResolveRef<RefShape, FullyResolvedSchema, NonModelTypes, CustomOperations> : Shape['returnType'] extends BaseModelField<infer R> ? R : Shape['returnType'] extends CustomType<infer R> ? ResolveFieldRequirements<FieldTypesOfCustomType<{
     thisCustomType: R['fields'];
 }>['thisCustomType']> | null : never;
 /**

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

@@ -1,10 +1,10 @@
 import type { UnionToIntersection } from '@aws-amplify/data-schema-types';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type { SchemaTypes, ModelAndCustomTypes, FieldTypesOfCustomType } from './ResolveSchema';
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 export type NonModelTypesShape = {
-    enums: Record<string, EnumType<any>>;
+    enums: Record<string, any>;
     customTypes: Record<string, any>;
 };
 export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModelTypes<Schema, ExtractImplicitNonModelTypes<Schema>>>;
@@ -40,7 +40,7 @@ export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModel
  * ```
  */
 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> ? {
+    [FieldProp in keyof Fields as Fields[FieldProp] extends EnumType | CustomType<CustomTypeParamShape> ? FieldProp : never]: (x: NonNullable<Fields[FieldProp]> extends infer FieldType ? FieldType extends EnumType ? {
         [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']> & {
@@ -60,7 +60,7 @@ export type ExtractImplicitNonModelTypes<Schema, Targets = ModelAndCustomTypes<S
 }[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;
+        [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType ? Model : never]: ResolvedSchema[Model] extends EnumType<infer values> ? values[number] : never;
     };
     customTypes: {
         [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends CustomType<CustomTypeParamShape> ? Model : never]: ResolvedSchema[Model] extends CustomType<infer R extends CustomTypeParamShape> ? R['fields'] : never;

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

@@ -11,7 +11,7 @@ import type { ModelIdentifier } from './ModelMetadata';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+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;
@@ -57,7 +57,7 @@ type Intersection<A = Record<never, never>, B = Record<never, never>, C = Record
     [P in keyof U]: U[P];
 } : never;
 export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
-    [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape> ? 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;
+    [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>;

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

@@ -1,9 +1,9 @@
 import type { ModelType } from '../ModelType';
 import type { GenericModelSchema } from '../ModelSchema';
 import type { ModelRelationalField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationalField';
-import type { ModelField } from '../ModelField';
+import type { BaseModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
@@ -16,14 +16,14 @@ export type SchemaTypes<T> = T extends GenericModelSchema<any> ? T['data']['type
  * added to ModelMeta in ClientSchema.ts
  */
 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;
+    [Model in keyof Schema as Schema[Model] extends EnumType | 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;
+    [Model in keyof Schema as Schema[Model] extends EnumType | CustomOperation<CustomOperationParamShape, any> ? never : Model]: Schema[Model] extends ModelType<any, any> | CustomType<CustomTypeParamShape> ? Schema[Model] : never;
 };
 /**
  * Resolves field types
@@ -32,7 +32,7 @@ export type ModelAndCustomTypes<Schema> = {
  */
 export type FieldTypes<T> = {
     [ModelProp in keyof T]: {
-        [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['valueRequired'] 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 BaseModelField<infer R> ? R : T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<ModelProp & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
             valueRequired: false;
@@ -52,7 +52,7 @@ export type FieldTypes<T> = {
  */
 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['valueRequired'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
+        [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends BaseModelField<infer R> ? R : T[CustomTypeName][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['valueRequired'] extends true ? T[CustomTypeName][FieldProp] : T[CustomTypeName][FieldProp] | null : T[CustomTypeName][FieldProp] extends EnumType | CustomType<CustomTypeParamShape> ? RefType<{
             link: `${Capitalize<CustomTypeName & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
             valueRequired: false;

package/dist/esm/ModelField.d.ts

@@ -1,5 +1,6 @@
-import { Brand } from './util';
 import { AllowModifier, Authorization } from './Authorization';
+import type { methodKeyOf, satisfy } from './util/usedMethods.js';
+import type { brandSymbol } from './util/Brand.js';
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
@@ -45,42 +46,44 @@ export type ModelFieldTypeParamOuter = ModelFieldTypeParamInner | Array<ModelFie
 export type Nullable<T> = T | null;
 export type Required<T> = Exclude<T, null>;
 export type ArrayField<T> = [T] extends [ModelFieldTypeParamInner] ? Array<T> | null : never;
+export type BaseModelField<T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter> = ModelField<T, UsableModelFieldKey, any>;
+export type UsableModelFieldKey = satisfy<methodKeyOf<ModelField>, 'required' | 'default' | 'authorization'>;
 /**
  * Public API for the chainable builder methods exposed by Model Field.
  * The type is narrowing e.g., after calling .array() it will be omitted from intellisense suggestions
  *
  * @typeParam T - holds the JS data type of the field
- * @typeParam K - union of strings representing already-invoked method names. Used to improve Intellisense
+ * @typeParam UsedMethod - union of strings representing already-invoked method names. Used to improve Intellisense
  */
-export type ModelField<T extends ModelFieldTypeParamOuter, K extends keyof ModelField<T> = never, Auth = undefined> = Omit<{
+export type ModelField<T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter, UsedMethod extends UsableModelFieldKey = never, Auth = undefined> = Omit<{
+    [__auth]?: Auth;
+    [brandSymbol]: typeof brandName;
     /**
      * Marks a field as required.
      */
-    required(): ModelField<Required<T>, K | 'required'>;
+    required(): ModelField<Required<T>, UsedMethod | 'required'>;
     /**
      * Converts a field type definition to an array of the field type.
      */
-    array(): ModelField<ArrayField<T>, Exclude<K, 'required'> | 'array'>;
+    array(): ModelField<ArrayField<T>, Exclude<UsedMethod, 'required'>>;
     /**
      * Sets a default value for the scalar type.
      * @param value the default value
      */
-    default(value: ModelFieldTypeParamOuter): ModelField<T, K | 'default'>;
+    default(value: ModelFieldTypeParamOuter): ModelField<T, UsedMethod | 'default'>;
     /**
-     * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
+     * 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: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelField<T, K | 'authorization', AuthRuleType>;
-}, K> & {
-    [__auth]?: Auth;
-} & Brand<typeof brandName>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelField<T, UsedMethod | 'authorization', AuthRuleType>;
+}, UsedMethod>;
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.
  */
-export type InternalField = ModelField<ModelFieldTypeParamOuter, never> & {
+export interface InternalField extends ModelField {
     data: FieldData;
-};
+}
 /**
  * A unique identifier scalar type. This scalar is serialized like a String but isn't meant to be human-readable.
  * If not specified on create operations, a ULID will be auto-generated service-side.

package/dist/esm/ModelRelationalField.d.ts

@@ -41,7 +41,7 @@ type ModelRelationalFieldFunctions<T extends ModelRelationalFieldParamShape, RM
      */
     required(): ModelRelationalField<SetTypeSubArg<T, 'arrayRequired', true>, K | 'required'>;
     /**
-     * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
+     * 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>;
@@ -67,24 +67,103 @@ export type ModelRelationalTypeArgFactory<RM extends string, RT extends Relation
     references: string[];
 };
 /**
- * Create a one-directional one-to-one relationship between two models using the `hasOne("MODEL_NAME")` method.
+ * Create one-to-one relationship between two models using the `hasOne("MODEL_NAME", "REFERENCE_FIELD(s)")` method.
  * A hasOne relationship always uses a reference to the related model's identifier. Typically this is the `id` field
  * unless overwritten with the `identifier()` method.
+ * @example
+ * const schema = a.schema({
+ *   Cart: a.model({
+ *     items: a.string().required().array(),
+ *     // 1. Create reference field
+ *     customerId: a.id(),
+ *     // 2. Create relationship field with the reference field
+ *     customer: a.belongsTo('Customer', 'customerId'),
+ *   }),
+ *   Customer: a.model({
+ *     name: a.string(),
+ *     // 3. Create relationship field with the reference field
+ *     //    from the Cart model
+ *     activeCart: a.hasOne('Cart', 'customerId')
+ *   }),
+ * });
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/#model-a-one-to-one-relationship}
  * @param relatedModel the name of the related model
+ * @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>;
 /**
- * Create a one-directional one-to-many relationship between two models using the `hasMany()` method.
+ * Create a one-directional one-to-many relationship between two models using the `hasMany("MODEL_NAME", "REFERENCE_FIELD(s)")` method.
+ * @example
+ * const schema = a.schema({
+ *   Member: a.model({
+ *     name: a.string().required(),
+ *     // 1. Create a reference field
+ *     teamId: a.id(),
+ *     // 2. Create a belongsTo relationship with the reference field
+ *     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
+ *     //    from the `Member`s model.
+ *     members: a.hasMany('Member', 'teamId'),
+ *   })
+ *   .authorization(allow => [allow.publicApiKey()]),
+ * });
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/#model-one-to-many-relationships}
  * @param relatedModel the name of the related model
+ * @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>;
 /**
- * Make a `hasOne()` or `hasMany()` relationship bi-directional using the `belongsTo()` method.
+ * 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
+ * // one-to-many relationship
+ * const schema = a.schema({
+ *   Member: a.model({
+ *     name: a.string().required(),
+ *     // 1. Create a reference field
+ *     teamId: a.id(),
+ *     // 2. Create a belongsTo relationship with the reference field
+ *     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
+ *     //    from the `Member`s model.
+ *     members: a.hasMany('Member', 'teamId'),
+ *   })
+ *   .authorization(allow => [allow.publicApiKey()]),
+ * });
+ * @example
+ * // one-to-one relationship
+ * const schema = a.schema({
+ *   Cart: a.model({
+ *     items: a.string().required().array(),
+ *     // 1. Create reference field
+ *     customerId: a.id(),
+ *     // 2. Create relationship field with the reference field
+ *     customer: a.belongsTo('Customer', 'customerId'),
+ *   }),
+ *   Customer: a.model({
+ *     name: a.string(),
+ *     // 3. Create relationship field with the reference field
+ *     //    from the Cart model
+ *     activeCart: a.hasOne('Cart', 'customerId')
+ *   }),
+ * });
+ * @see {@link https://docs.amplify.aws/react/build-a-backend/data/data-modeling/relationships/}
  * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model
+ * @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>;