@aws-amplify/data-schema 1.9.2 → 1.10.1

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) &&