@aws-amplify/data-schema 1.3.10 → 1.4.0

package/src/runtime/internals/utils/clientProperties/generateModelsProperty.ts

@@ -9,13 +9,16 @@ import {
   ModelIntrospectionSchema,
 } 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 { subscriptionFactory } from '../../operations/subscription';
 import { observeQueryFactory } from '../../operations/observeQuery';
-import { getSecondaryIndexesFromSchemaModel } from '../../clientUtils';
+import {
+  getSecondaryIndexesFromSchemaModel,
+  excludeDisabledOps,
+} from '../../clientUtils';
 
 export function generateModelsProperty<T extends Record<any, any> = never>(
   client: BaseClient,
@@ -38,38 +41,38 @@ export function generateModelsProperty<T extends Record<any, any> = never>(
 
     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;
 
-        if (operation === 'LIST') {
-          models[name][operationPrefix] = listFactory(
-            client,
-            modelIntrospection,
-            model,
-            getInternals,
-          );
-        } else if (SUBSCRIPTION_OPS.includes(operation)) {
-          models[name][operationPrefix] = subscriptionFactory(
-            client as BaseBrowserClient,
-            modelIntrospection,
-            model,
-            operation,
-            getInternals,
-          );
-        } else if (operation === 'OBSERVE_QUERY') {
-          models[name][operationPrefix] = observeQueryFactory(models, model);
-        } else {
-          models[name][operationPrefix] = getFactory(
-            client,
-            modelIntrospection,
-            model,
-            operation,
-            getInternals,
-          );
-        }
-      },
-    );
+      if (operation === 'LIST') {
+        models[name][operationPrefix] = listFactory(
+          client,
+          modelIntrospection,
+          model,
+          getInternals,
+        );
+      } else if (SUBSCRIPTION_OPS.includes(operation)) {
+        models[name][operationPrefix] = subscriptionFactory(
+          client as BaseBrowserClient,
+          modelIntrospection,
+          model,
+          operation,
+          getInternals,
+        );
+      } else if (operation === 'OBSERVEQUERY') {
+        models[name][operationPrefix] = observeQueryFactory(models, model);
+      } else {
+        models[name][operationPrefix] = getFactory(
+          client,
+          modelIntrospection,
+          model,
+          operation,
+          getInternals,
+        );
+      }
+    });
 
     const secondaryIdxs = getSecondaryIndexesFromSchemaModel(model);
 

package/src/runtime/utils/index.ts

@@ -5,3 +5,4 @@ export { resolvePKFields } from './resolvePKFields';
 export { findIndexByFields } from './findIndexByFields';
 export { resolveOwnerFields } from './resolveOwnerFields';
 export { capitalize } from './stringTransformation';
+export { selfAwareAsync } from './selfAwareAsync';

package/src/runtime/utils/selfAwareAsync.ts

@@ -0,0 +1,39 @@
+/**
+ * Executes an `async` resolver function, providing the `Promise`-to-be-returned as the
+ * first argument to the resolver so that the resolver can refer to the `Promise` that
+ * external callers will see.
+ *
+ * ```ts
+ * const outer = selfAwareAsync(async inner => {
+ *  console.log(outer === inner); // true
+ * });
+ * ```
+ *
+ * This utility exists to reduce boilerplate in cases where promise resolving code needs
+ * to track or register its "own" `Promise` *as seen by the caller* in some way. E.g.,
+ * when mapping `Promise` chains for `client.cancel()`.
+ *
+ * @param resolver
+ * @returns
+ */
+export function selfAwareAsync<T>(
+  resolver: (promise: Promise<T>) => Promise<T>,
+): Promise<T> {
+  let resolve: (value: T) => void;
+  let reject: (reason?: any) => void;
+
+  const resultPromise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+
+  resolver(resultPromise)
+    .then((result) => {
+      resolve(result);
+    })
+    .catch((error) => {
+      reject(error);
+    });
+
+  return resultPromise;
+}