@aws-amplify/data-schema 1.3.10 → 1.4.0

package/src/runtime/internals/operations/indexQuery.ts

@@ -22,6 +22,8 @@ import {
 } from '../APIClient';
 
 import { handleListGraphQlError } from './utils';
+import { selfAwareAsync } from '../../utils';
+import { extendCancellability } from '../cancellation';
 
 export interface IndexMeta {
   queryField: string;
@@ -37,7 +39,7 @@ export function indexQueryFactory(
   getInternals: ClientInternalsGetter,
   context = false,
 ) {
-  const indexQueryWithContext = async (
+  const indexQueryWithContext = (
     contextSpec: AmplifyServer.ContextSpec,
     args: QueryArgs,
     options?: ListArgs,
@@ -56,7 +58,7 @@ export function indexQueryFactory(
     );
   };
 
-  const indexQuery = async (args: QueryArgs, options?: ListArgs) => {
+  const indexQuery = (args: QueryArgs, options?: ListArgs) => {
     return _indexQuery(
       client,
       modelIntrospection,
@@ -104,7 +106,7 @@ function processGraphQlResponse(
   };
 }
 
-async function _indexQuery(
+function _indexQuery(
   client: BaseClient,
   modelIntrospection: ModelIntrospectionSchema,
   model: SchemaModel,
@@ -113,108 +115,112 @@ async function _indexQuery(
   args?: ListArgs & AuthModeParams,
   contextSpec?: AmplifyServer.ContextSpec,
 ) {
-  const { name } = model;
-
-  const query = generateGraphQLDocument(
-    modelIntrospection,
-    name,
-    'INDEX_QUERY',
-    args,
-    indexMeta,
-  );
-  const variables = buildGraphQLVariables(
-    model,
-    'INDEX_QUERY',
-    args,
-    modelIntrospection,
-    indexMeta,
-  );
-
-  const auth = authModeParams(client, getInternals, args);
-
-  const modelInitializer = (flattenedResult: any[]) =>
-    initializeModel(
-      client,
+  return selfAwareAsync(async (resultPromise) => {
+    const { name } = model;
+
+    const query = generateGraphQLDocument(
+      modelIntrospection,
       name,
-      flattenedResult,
+      'INDEX_QUERY',
+      args,
+      indexMeta,
+    );
+    const variables = buildGraphQLVariables(
+      model,
+      'INDEX_QUERY',
+      args,
       modelIntrospection,
-      auth.authMode,
-      auth.authToken,
-      !!contextSpec,
+      indexMeta,
     );
 
-  try {
-    const headers = getCustomHeaders(client, getInternals, args?.headers);
+    const auth = authModeParams(client, getInternals, args);
 
-    const graphQlParams = {
-      ...auth,
-      query,
-      variables,
-    };
+    const modelInitializer = (flattenedResult: any[]) =>
+      initializeModel(
+        client,
+        name,
+        flattenedResult,
+        modelIntrospection,
+        auth.authMode,
+        auth.authToken,
+        !!contextSpec,
+      );
 
-    const requestArgs: [any, any] = [graphQlParams, headers];
+    try {
+      const headers = getCustomHeaders(client, getInternals, args?.headers);
 
-    if (contextSpec !== undefined) {
-      requestArgs.unshift(contextSpec);
-    }
+      const graphQlParams = {
+        ...auth,
+        query,
+        variables,
+      };
 
-    const response = (await (client as BaseClient).graphql(
-      ...requestArgs,
-    )) as GraphQLResult;
+      const requestArgs: [any, any] = [graphQlParams, headers];
 
-    if (response.data !== undefined) {
-      return processGraphQlResponse(
-        modelIntrospection,
-        name,
-        response,
-        args?.selectionSet,
-        modelInitializer,
-      );
-    }
-  } catch (error: any) {
-    /**
-     * The `data` type returned by `error` here could be:
-     * 1) `null`
-     * 2) an empty object
-     * 3) "populated" but with a `null` value:
-     *   `data: { listByExampleId: null }`
-     * 4) an actual record:
-     *   `data: { listByExampleId: items: [{ id: '1', ...etc } }]`
-     */
-    const { data, errors } = error;
-
-    // `data` is not `null`, and is not an empty object:
-    if (data !== undefined && Object.keys(data).length !== 0 && errors) {
-      const [key] = Object.keys(data);
-
-      if (data[key]?.items) {
-        const flattenedResult = data[key]?.items.map(
-          (value: Record<string, any>) =>
-            flattenItems(modelIntrospection, name, value),
-        );
+      if (contextSpec !== undefined) {
+        requestArgs.unshift(contextSpec);
+      }
 
-        /**
-         * Check exists since `flattenedResult` could be `null`.
-         * if `flattenedResult` exists, result is an actual record.
-         */
-        if (flattenedResult) {
-          return {
-            data: args?.selectionSet
-              ? flattenedResult
-              : modelInitializer(flattenedResult),
-            nextToken: data[key]?.nextToken,
-          };
-        }
+      const basePromise = (client as BaseClient).graphql(
+        ...requestArgs,
+      ) as Promise<GraphQLResult>;
+      const extendedPromise = extendCancellability(basePromise, resultPromise);
+      const response = await extendedPromise;
+
+      if (response.data !== undefined) {
+        return processGraphQlResponse(
+          modelIntrospection,
+          name,
+          response,
+          args?.selectionSet,
+          modelInitializer,
+        );
       }
+    } catch (error: any) {
+      /**
+       * The `data` type returned by `error` here could be:
+       * 1) `null`
+       * 2) an empty object
+       * 3) "populated" but with a `null` value:
+       *   `data: { listByExampleId: null }`
+       * 4) an actual record:
+       *   `data: { listByExampleId: items: [{ id: '1', ...etc } }]`
+       */
+      const { data, errors } = error;
+
+      // `data` is not `null`, and is not an empty object:
+      if (data !== undefined && Object.keys(data).length !== 0 && errors) {
+        const [key] = Object.keys(data);
+
+        if (data[key]?.items) {
+          const flattenedResult = data[key]?.items.map(
+            (value: Record<string, any>) =>
+              flattenItems(modelIntrospection, name, value),
+          );
+
+          /**
+           * Check exists since `flattenedResult` could be `null`.
+           * if `flattenedResult` exists, result is an actual record.
+           */
+          if (flattenedResult) {
+            return {
+              data: args?.selectionSet
+                ? flattenedResult
+                : modelInitializer(flattenedResult),
+              nextToken: data[key]?.nextToken,
+            };
+          }
+        }
 
-      // response is of type `data: { listByExampleId: null }`
-      return {
-        data: data[key],
-        nextToken: data[key]?.nextToken,
-      };
-    } else {
-      // `data` is `null` or an empty object:
-      return handleListGraphQlError(error);
+        // response is of type `data: { listByExampleId: null }`
+        return {
+          data: data[key],
+          nextToken: data[key]?.nextToken,
+        };
+      } else {
+        // `data` is `null` or an empty object:
+        return handleListGraphQlError(error);
+      }
     }
-  }
+  });
 }

package/src/runtime/internals/operations/list.ts

@@ -23,6 +23,9 @@ import {
 } from '../APIClient';
 
 import { handleListGraphQlError } from './utils';
+import { selfAwareAsync } from '../../utils';
+
+import { extendCancellability } from '../cancellation';
 
 export function listFactory(
   client: BaseClient,
@@ -31,7 +34,7 @@ export function listFactory(
   getInternals: ClientInternalsGetter,
   context = false,
 ) {
-  const listWithContext = async (
+  const listWithContext = (
     contextSpec: AmplifyServer.ContextSpec,
     args?: ListArgs,
   ) => {
@@ -45,14 +48,14 @@ export function listFactory(
     );
   };
 
-  const list = async (args?: Record<string, any>) => {
+  const list = (args?: Record<string, any>) => {
     return _list(client, modelIntrospection, model, getInternals, args);
   };
 
   return context ? listWithContext : list;
 }
 
-async function _list(
+function _list(
   client: BaseClient,
   modelIntrospection: ModelIntrospectionSchema,
   model: SchemaModel,
@@ -60,118 +63,65 @@ async function _list(
   args?: ListArgs & AuthModeParams,
   contextSpec?: AmplifyServer.ContextSpec,
 ) {
-  const { name } = model;
-
-  const query = generateGraphQLDocument(modelIntrospection, name, 'LIST', args);
-  const variables = buildGraphQLVariables(
-    model,
-    'LIST',
-    args,
-    modelIntrospection,
-  );
-
-  const auth = authModeParams(client, getInternals, args);
-
-  try {
-    const headers = getCustomHeaders(client, getInternals, args?.headers);
-
-    const { data, extensions } = contextSpec
-      ? ((await (client as BaseSSRClient).graphql(
-          contextSpec,
-          {
-            ...auth,
-            query,
-            variables,
-          },
-          headers,
-        )) as GraphQLResult)
-      : ((await (client as BaseBrowserClient).graphql(
-          {
-            ...auth,
-            query,
-            variables,
-          },
-          headers,
-        )) as GraphQLResult);
-
-    // flatten response
-    if (data !== undefined) {
-      const [key] = Object.keys(data);
-
-      if (data[key].items) {
-        const flattenedResult = data[key].items.map(
-          (value: Record<string, any>) =>
-            flattenItems(modelIntrospection, name, value),
-        );
-
-        // don't init if custom selection set
-        if (args?.selectionSet) {
-          return {
-            data: flattenedResult,
-            nextToken: data[key].nextToken,
-            extensions,
-          };
-        } else {
-          const initialized = initializeModel(
-            client,
-            name,
-            flattenedResult,
-            modelIntrospection,
-            auth.authMode,
-            auth.authToken,
-            !!contextSpec,
-          );
+  return selfAwareAsync(async (resultPromise) => {
+    const { name } = model;
 
-          return {
-            data: initialized,
-            nextToken: data[key].nextToken,
-            extensions,
-          };
-        }
-      }
+    const query = generateGraphQLDocument(
+      modelIntrospection,
+      name,
+      'LIST',
+      args,
+    );
+    const variables = buildGraphQLVariables(
+      model,
+      'LIST',
+      args,
+      modelIntrospection,
+    );
+
+    const auth = authModeParams(client, getInternals, args);
+
+    try {
+      const headers = getCustomHeaders(client, getInternals, args?.headers);
+
+      const basePromise = contextSpec
+        ? ((client as BaseSSRClient).graphql(
+            contextSpec,
+            {
+              ...auth,
+              query,
+              variables,
+            },
+            headers,
+          ) as Promise<GraphQLResult>)
+        : ((client as BaseBrowserClient).graphql(
+            {
+              ...auth,
+              query,
+              variables,
+            },
+            headers,
+          ) as Promise<GraphQLResult>);
+
+      const extendedPromise = extendCancellability(basePromise, resultPromise);
+      const { data, extensions } = await extendedPromise;
+
+      // flatten response
+      if (data !== undefined) {
+        const [key] = Object.keys(data);
+
+        if (data[key].items) {
+          const flattenedResult = data[key].items.map(
+            (value: Record<string, any>) =>
+              flattenItems(modelIntrospection, name, value),
+          );
 
-      return {
-        data: data[key],
-        nextToken: data[key].nextToken,
-        extensions,
-      };
-    }
-  } catch (error: any) {
-    /**
-     * The `data` type returned by `error` here could be:
-     * 1) `null`
-     * 2) an empty object
-     * 3) "populated" but with a `null` value `data: { listPosts: null }`
-     * 4) actual records `data: { listPosts: items: [{ id: '1', ...etc }] }`
-     */
-    const { data, errors } = error;
-
-    // `data` is not `null`, and is not an empty object:
-    if (
-      data !== undefined &&
-      data !== null &&
-      Object.keys(data).length !== 0 &&
-      errors
-    ) {
-      const [key] = Object.keys(data);
-
-      if (data[key]?.items) {
-        const flattenedResult = data[key].items.map(
-          (value: Record<string, any>) =>
-            flattenItems(modelIntrospection, name, value),
-        );
-
-        /**
-         * Check exists since `flattenedResult` could be `null`.
-         * if `flattenedResult` exists, result is an actual record.
-         */
-        if (flattenedResult) {
           // don't init if custom selection set
           if (args?.selectionSet) {
             return {
               data: flattenedResult,
-              nextToken: data[key]?.nextToken,
-              errors,
+              nextToken: data[key].nextToken,
+              extensions,
             };
           } else {
             const initialized = initializeModel(
@@ -184,27 +134,90 @@ async function _list(
               !!contextSpec,
             );
 
-            // data is full record w/out selection set:
             return {
               data: initialized,
-              nextToken: data[key]?.nextToken,
-              errors,
+              nextToken: data[key].nextToken,
+              extensions,
             };
           }
         }
 
         return {
           data: data[key],
-          nextToken: data[key]?.nextToken,
-          errors,
+          nextToken: data[key].nextToken,
+          extensions,
         };
+      }
+    } catch (error: any) {
+      /**
+       * The `data` type returned by `error` here could be:
+       * 1) `null`
+       * 2) an empty object
+       * 3) "populated" but with a `null` value `data: { listPosts: null }`
+       * 4) actual records `data: { listPosts: items: [{ id: '1', ...etc }] }`
+       */
+      const { data, errors } = error;
+
+      // `data` is not `null`, and is not an empty object:
+      if (
+        data !== undefined &&
+        data !== null &&
+        Object.keys(data).length !== 0 &&
+        errors
+      ) {
+        const [key] = Object.keys(data);
+
+        if (data[key]?.items) {
+          const flattenedResult = data[key].items.map(
+            (value: Record<string, any>) =>
+              flattenItems(modelIntrospection, name, value),
+          );
+
+          /**
+           * Check exists since `flattenedResult` could be `null`.
+           * if `flattenedResult` exists, result is an actual record.
+           */
+          if (flattenedResult) {
+            // don't init if custom selection set
+            if (args?.selectionSet) {
+              return {
+                data: flattenedResult,
+                nextToken: data[key]?.nextToken,
+                errors,
+              };
+            } else {
+              const initialized = initializeModel(
+                client,
+                name,
+                flattenedResult,
+                modelIntrospection,
+                auth.authMode,
+                auth.authToken,
+                !!contextSpec,
+              );
+
+              // data is full record w/out selection set:
+              return {
+                data: initialized,
+                nextToken: data[key]?.nextToken,
+                errors,
+              };
+            }
+          }
+
+          return {
+            data: data[key],
+            nextToken: data[key]?.nextToken,
+            errors,
+          };
+        } else {
+          // response is of type `data: { getPost: null }`)
+          return handleListGraphQlError(error);
+        }
       } else {
-        // response is of type `data: { getPost: null }`)
+        // `data` is `null` or an empty object:
         return handleListGraphQlError(error);
       }
-    } else {
-      // `data` is `null` or an empty object:
-      return handleListGraphQlError(error);
     }
-  }
+  });
 }

package/src/runtime/internals/server/generateModelsProperty.ts

@@ -8,11 +8,14 @@ import {
   ServerClientGenerationParams,
 } from '../../bridge-types';
 
-import { ModelOperation, graphQLOperationsInfo } from '../APIClient';
+import { ModelOperation } from '../APIClient';
 import { listFactory } from '../operations/list';
 import { indexQueryFactory } from '../operations/indexQuery';
 import { getFactory } from '../operations/get';
-import { getSecondaryIndexesFromSchemaModel } from '../clientUtils';
+import {
+  getSecondaryIndexesFromSchemaModel,
+  excludeDisabledOps,
+} from '../clientUtils';
 
 export function generateModelsProperty<T extends Record<any, any> = never>(
   client: BaseClient,
@@ -42,40 +45,40 @@ export function generateModelsProperty<T extends Record<any, any> = never>(
     'ONCREATE',
     'ONUPDATE',
     'ONDELETE',
-    'OBSERVE_QUERY',
+    'OBSERVEQUERY',
   ];
 
   for (const model of Object.values(modelIntrospection.models)) {
     const { name } = model;
     models[name] = {} as Record<string, any>;
 
-    Object.entries(graphQLOperationsInfo).forEach(
-      ([key, { operationPrefix }]) => {
-        const operation = key as ModelOperation;
+    const enabledModelOps = excludeDisabledOps(modelIntrospection, name);
+
+    Object.entries(enabledModelOps).forEach(([key, { operationPrefix }]) => {
+      const operation = key as ModelOperation;
 
-        // subscriptions are not supported in SSR
-        if (SSR_UNSUPORTED_OPS.includes(operation)) return;
+      // subscriptions are not supported in SSR
+      if (SSR_UNSUPORTED_OPS.includes(operation)) return;
 
-        if (operation === 'LIST') {
-          models[name][operationPrefix] = listFactory(
-            client,
-            modelIntrospection,
-            model,
-            getInternals,
-            useContext,
-          );
-        } else {
-          models[name][operationPrefix] = getFactory(
-            client,
-            modelIntrospection,
-            model,
-            operation,
-            getInternals,
-            useContext,
-          );
-        }
-      },
-    );
+      if (operation === 'LIST') {
+        models[name][operationPrefix] = listFactory(
+          client,
+          modelIntrospection,
+          model,
+          getInternals,
+          useContext,
+        );
+      } else {
+        models[name][operationPrefix] = getFactory(
+          client,
+          modelIntrospection,
+          model,
+          operation,
+          getInternals,
+          useContext,
+        );
+      }
+    });
 
     const secondaryIdxs = getSecondaryIndexesFromSchemaModel(model);