@aws-amplify/data-schema 0.14.4 → 0.14.6

package/lib-esm/src/SchemaProcessor.js

@@ -183,19 +183,51 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
     const { authString } = isCustom
         ? calculateCustomAuth(authorization)
         : calculateAuth(authorization);
+    /**
+     *
+     * @param returnType The return type from the `data` field of a customer operation.
+     * @param refererTypeName The type the refers {@link returnType} by `a.ref()`.
+     * @param shouldAddCustomTypeToImplicitModels A flag indicates wether it should push
+     * the return type resolved CustomType to the `implicitModels` list.
+     * @returns
+     */
+    const resolveReturnTypeNameFromReturnType = (returnType, { refererTypeName, shouldAddCustomTypeToImplicitModels = true, }) => {
+        if (isRefField(returnType)) {
+            return refFieldToGql(returnType?.data);
+        }
+        else if (isCustomType(returnType)) {
+            const returnTypeName = `${capitalize(refererTypeName)}ReturnType`;
+            if (shouldAddCustomTypeToImplicitModels) {
+                implicitModels.push([returnTypeName, returnType]);
+            }
+            return returnTypeName;
+        }
+        else if (isScalarField(returnType)) {
+            return scalarFieldToGql(returnType?.data);
+        }
+        else {
+            throw new Error(`Unrecognized return type on ${typeName}`);
+        }
+    };
     let returnTypeName;
-    if (isRefField(returnType)) {
-        returnTypeName = refFieldToGql(returnType?.data);
-    }
-    else if (isCustomType(returnType)) {
-        returnTypeName = `${capitalize(typeName)}ReturnType`;
-        implicitModels.push([returnTypeName, returnType]);
-    }
-    else if (isScalarField(returnType)) {
-        returnTypeName = scalarFieldToGql(returnType?.data);
+    if (opType === 'Subscription' && returnType === null) {
+        // up to this point, we've validated that each subscription resource resolves
+        // the same return type, so it's safe to use subscriptionSource[0] here.
+        const { type, def } = getRefType(subscriptionSource[0].data.link, typeName);
+        if (type === 'CustomOperation') {
+            returnTypeName = resolveReturnTypeNameFromReturnType(def.data.returnType, {
+                refererTypeName: subscriptionSource[0].data.link,
+                shouldAddCustomTypeToImplicitModels: false,
+            });
+        }
+        else {
+            returnTypeName = refFieldToGql(subscriptionSource[0].data);
+        }
     }
     else {
-        throw new Error(`Unrecognized return type on ${typeName}`);
+        returnTypeName = resolveReturnTypeNameFromReturnType(returnType, {
+            refererTypeName: typeName,
+        });
     }
     if (Object.keys(fieldArgs).length > 0) {
         const { gqlFields, models } = processFields(typeName, fieldArgs, {}, {});
@@ -875,7 +907,7 @@ const schemaPreprocessor = (schema) => {
     };
 };
 function validateCustomOperations(typeDef, typeName, authRules, getRefType) {
-    const { functionRef, handlers, typeName: opType, subscriptionSource, returnType, } = typeDef.data;
+    const { functionRef, handlers, typeName: opType, subscriptionSource, } = typeDef.data;
     // TODO: remove `functionRef` after deprecating
     const handlerConfigured = functionRef !== null || handlers?.length;
     const authConfigured = authRules.length > 0;
@@ -902,52 +934,43 @@ function validateCustomOperations(typeDef, typeName, authRules, getRefType) {
         if (subscriptionSource.length < 1) {
             throw new Error(`${typeName} is missing a mutation source. Custom subscriptions must reference a mutation source via subscription().for(a.ref('ModelOrOperationName')) `);
         }
-        subscriptionSource.forEach((source) => {
+        let expectedReturnType;
+        for (const source of subscriptionSource) {
             const sourceName = source.data.link;
             const { type, def } = getRefType(sourceName, typeName);
             if (type !== 'Model' && source.data.mutationOperations.length > 0) {
                 throw new Error(`Invalid subscription definition. .mutations() modifier can only be used with a Model ref. ${typeName} is referencing ${type}`);
             }
-            if (type === 'Model' && source.data.mutationOperations.length === 0) {
-                throw new Error(`Invalid subscription definition. .mutations() modifier must be used with a Model ref subscription source. ${typeName} is referencing ${sourceName} without specifying a mutation`);
-            }
-            if (type === 'CustomOperation' && def.data.typeName !== 'Mutation') {
-                throw new Error(`Invalid subscription definition. .for() can only reference a mutation. ${typeName} is referencing ${sourceName} which is a ${def.data.typeName}`);
-            }
-            // Ensure subscription return type matches the return type of triggering mutation(s)
-            // TODO: when we remove .returns() for custom subscriptions, minor changes will be needed here. Instead of comparing subscriptionSource return val
-            //  to a root returnType, we'll need to ensure that each subscriptionSource has the same return type
-            if (returnType.data.type === 'ref') {
-                const returnTypeName = returnType.data.link;
-                if (type === 'Model') {
-                    if (returnTypeName !== sourceName ||
-                        returnType.data.array !== source.data.array) {
-                        throw new Error(`Invalid subscription definition. Subscription return type must match the return type of the mutation triggering it. ${typeName} is referencing ${sourceName} which has a different return type`);
-                    }
+            let resolvedReturnType;
+            if (type === 'Model') {
+                if (source.data.mutationOperations.length === 0) {
+                    throw new Error(`Invalid subscription definition. .mutations() modifier must be used with a Model ref subscription source. ${typeName} is referencing ${sourceName} without specifying a mutation`);
                 }
-                if (type === 'CustomOperation') {
-                    const customOperationReturnType = def.data.returnType.data.link;
-                    const customOperationReturnTypeArray = def.data.returnType.data.array;
-                    if (returnTypeName !== customOperationReturnType ||
-                        returnType.data.array !== customOperationReturnTypeArray) {
-                        throw new Error(`Invalid subscription definition. Subscription return type must match the return type of the mutation triggering it. ${typeName} is referencing ${sourceName} which has a different return type`);
-                    }
+                else {
+                    resolvedReturnType = def;
                 }
             }
-            else if (returnType.data.fieldType !== undefined) {
-                if (type === 'Model') {
-                    throw new Error(`Invalid subscription definition. Subscription return type must match the return type of the mutation triggering it. ${typeName} is referencing ${sourceName} which has a different return type`);
+            if (type === 'CustomOperation') {
+                if (def.data.typeName !== 'Mutation') {
+                    throw new Error(`Invalid subscription definition. .for() can only reference a mutation. ${typeName} is referencing ${sourceName} which is a ${def.data.typeName}`);
                 }
-                if (type === 'CustomOperation') {
-                    const customOperationReturnType = def.data.returnType.data.fieldType;
-                    const customOperationReturnTypeArray = def.data.returnType.data.array;
-                    if (returnType.data.fieldType !== customOperationReturnType ||
-                        returnType.data.array !== customOperationReturnTypeArray) {
-                        throw new Error(`Invalid subscription definition. Subscription return type must match the return type of the mutation triggering it. ${typeName} is referencing ${sourceName} which has a different return type`);
+                else {
+                    const returnType = def.data.returnType;
+                    if (isRefField(returnType)) {
+                        ({ def: resolvedReturnType } = getRefType(returnType.data.link, typeName));
+                    }
+                    else {
+                        resolvedReturnType = returnType;
                     }
                 }
             }
-        });
+            expectedReturnType = expectedReturnType ?? resolvedReturnType;
+            // As the return types are resolved from the root `schema` object and they should
+            // not be mutated, we compare by references here.
+            if (expectedReturnType !== resolvedReturnType) {
+                throw new Error(`Invalid subscription definition. .for() can only reference resources that have the same return type. ${typeName} is referencing resources that have different return types.`);
+            }
+        }
     }
 }
 const isCustomHandler = (handler) => {

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

@@ -10,3 +10,4 @@ import { enumType } from './EnumType';
 import { query, mutation, subscription } from './CustomOperation';
 import { handler } from './Handler';
 export { schema, combine, model, ref, customType, enumType as enum, query, mutation, subscription, hasOne, hasMany, belongsTo, manyToMany, allow, id, string, integer, float, boolean, date, time, datetime, timestamp, email, json, phone, url, ipAddress, handler, };
+//# sourceMappingURL=index.d.ts.map

package/lib-esm/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EACL,EAAE,EACF,MAAM,EACN,OAAO,EACP,KAAK,EACL,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,KAAK,EACL,IAAI,EACJ,KAAK,EACL,GAAG,EACH,SAAS,EACV,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,GAAG,EAAE,MAAM,WAAW,CAAC;AAChC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAChF,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAClE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,OAAO,EACL,MAAM,EACN,OAAO,EACP,KAAK,EACL,GAAG,EACH,UAAU,EACV,QAAQ,IAAI,IAAI,EAChB,KAAK,EACL,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,OAAO,EACP,SAAS,EACT,UAAU,EACV,KAAK,EACL,EAAE,EACF,MAAM,EACN,OAAO,EACP,KAAK,EACL,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,QAAQ,EACR,SAAS,EACT,KAAK,EACL,IAAI,EACJ,KAAK,EACL,GAAG,EACH,SAAS,EACT,OAAO,GACR,CAAC"}

package/lib-esm/src/internals/index.d.ts

@@ -1 +1,2 @@
 export { configure } from '../ModelSchema';
+//# sourceMappingURL=index.d.ts.map

package/lib-esm/src/internals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/internals/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/lib-esm/src/util/Brand.d.ts

@@ -33,3 +33,4 @@ export declare function brand<BrandStr extends string>(brand: BrandStr): Brand<B
  */
 export declare function getBrand(branded: Brand<string>): string;
 export {};
+//# sourceMappingURL=Brand.d.ts.map

package/lib-esm/src/util/Brand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Brand.d.ts","sourceRoot":"","sources":["../../../src/util/Brand.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,WAAW,eAAkB,CAAC;AAEpC;;;;;;;;;GASG;AACH,MAAM,MAAM,KAAK,CAAC,QAAQ,SAAS,MAAM,IAAI;IAC3C,CAAC,WAAW,CAAC,EAAE,QAAQ,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,QAAQ,SAAS,MAAM,EAC3C,KAAK,EAAE,QAAQ,GACd,KAAK,CAAC,QAAQ,CAAC,CAIjB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,UAE9C"}

package/lib-esm/src/util/IndexLimit.d.ts

@@ -5,3 +5,4 @@
  * @typeParam N - The number of literal values to include
  */
 export type IndexLimitUnion<N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : IndexLimitUnion<N, [...Result, `${Result['length']}`]>;
+//# sourceMappingURL=IndexLimit.d.ts.map

package/lib-esm/src/util/IndexLimit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IndexLimit.d.ts","sourceRoot":"","sources":["../../../src/util/IndexLimit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,MAAM,eAAe,CACzB,CAAC,SAAS,MAAM,EAChB,MAAM,SAAS,KAAK,CAAC,OAAO,CAAC,GAAG,EAAE,IAChC,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,GAC1B,MAAM,GACN,eAAe,CAAC,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC"}

package/lib-esm/src/util/SpreadTuple.d.ts

@@ -4,3 +4,4 @@
  * @typeParam T - The tuple of types to spread into a type intersection
  */
 export type SpreadTuple<T extends readonly any[]> = T extends [infer F] ? F : T extends [infer F, ...infer R] ? F & SpreadTuple<R> : never;
+//# sourceMappingURL=SpreadTuple.d.ts.map

package/lib-esm/src/util/SpreadTuple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpreadTuple.d.ts","sourceRoot":"","sources":["../../../src/util/SpreadTuple.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,GACnE,CAAC,GACD,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAAC,CAAC,GAC7B,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAClB,KAAK,CAAC"}

package/lib-esm/src/util/index.d.ts

@@ -1,3 +1,4 @@
 export { Brand, brand, getBrand } from './Brand';
 export { IndexLimitUnion } from './IndexLimit';
 export { SpreadTuple } from './SpreadTuple';
+//# sourceMappingURL=index.d.ts.map

package/lib-esm/src/util/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/util/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}