@aws-amplify/data-schema 0.16.2 → 0.17.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/data-schema",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

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

@@ -27,6 +27,8 @@ import {
   selectionSetIRToString,
 } from '../APIClient';
 
+import { handleSingularGraphQlError } from './utils';
+
 type CustomOperationOptions = AuthModeParams & ListArgs;
 
 // these are the 4 possible sets of arguments custom operations methods can receive
@@ -417,12 +419,49 @@ async function _op(
       return { data: null, extensions };
     }
   } catch (error: any) {
-    if (error.errors) {
-      // graphql errors pass through
-      return error as any;
+    /**
+     * The `data` type returned by `error` here could be:
+     * 1) `null`
+     * 2) an empty object
+     * 3) "populated" but with a `null` value `{ getPost: null }`
+     * 4) an actual record `{ getPost: { id: '1', title: 'Hello, World!' } }`
+     */
+    const { data, errors } = error;
+
+    /**
+     * `data` is not `null`, and is not an empty object:
+     */
+    if (data && Object.keys(data).length !== 0 && errors) {
+      const [key] = Object.keys(data);
+      const flattenedResult = flattenItems(data)[key];
+
+      /**
+       * `flattenedResult` could be `null` here (e.g. `data: { getPost: null }`)
+       * if `flattenedResult`, result is an actual record:
+       */
+      if (flattenedResult) {
+        // TODO: custom selection set. current selection set is default selection set only
+        // custom selection set requires data-schema-type + runtime updates above.
+        const [initialized] = returnTypeModelName
+          ? initializeModel(
+              client,
+              returnTypeModelName,
+              [flattenedResult],
+              modelIntrospection,
+              auth.authMode,
+              auth.authToken,
+              !!context,
+            )
+          : [flattenedResult];
+
+        return { data: initialized, errors };
+      } else {
+        // was `data: { getPost: null }`)
+        return handleSingularGraphQlError(error);
+      }
     } else {
-      // non-graphql errors re re-thrown
-      throw error;
+      // `data` is `null`:
+      return handleSingularGraphQlError(error);
     }
   }
 }

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

@@ -25,6 +25,8 @@ import {
   initializeModel,
 } from '../APIClient';
 
+import { handleSingularGraphQlError } from './utils';
+
 export function getFactory(
   client: BaseClient,
   modelIntrospection: ModelIntrospectionSchema,
@@ -90,9 +92,9 @@ async function _get(
     modelIntrospection,
   );
 
-  try {
-    const auth = authModeParams(client, getInternals, options);
+  const auth = authModeParams(client, getInternals, options);
 
+  try {
     const headers = getCustomHeaders(client, getInternals, options?.headers);
 
     const { data, extensions } = context
@@ -139,12 +141,50 @@ async function _get(
       return { data: null, extensions };
     }
   } catch (error: any) {
-    if (error.errors) {
-      // graphql errors pass through
-      return error as any;
+    /**
+     * The `data` type returned by `error` here could be:
+     * 1) `null`
+     * 2) an empty object
+     * 3) "populated" but with a `null` value `{ getPost: null }`
+     * 4) an actual record `{ getPost: { id: '1', title: 'Hello, World!' } }`
+     */
+    const { data, errors } = error;
+
+    /**
+     * `data` is not `null`, and is not an empty object:
+     */
+    if (data && Object.keys(data).length !== 0 && errors) {
+      const [key] = Object.keys(data);
+      const flattenedResult = flattenItems(data)[key];
+
+      /**
+       * `flattenedResult` could be `null` here (e.g. `data: { getPost: null }`)
+       * if `flattenedResult`, result is an actual record:
+       */
+      if (flattenedResult) {
+        if (options?.selectionSet) {
+          return { data: flattenedResult, errors };
+        } else {
+          // TODO: refactor to avoid destructuring here
+          const [initialized] = initializeModel(
+            client,
+            name,
+            [flattenedResult],
+            modelIntrospection,
+            auth.authMode,
+            auth.authToken,
+            !!context,
+          );
+
+          return { data: initialized, errors };
+        }
+      } else {
+        // was `data: { getPost: null }`)
+        return handleSingularGraphQlError(error);
+      }
     } else {
-      // non-graphql errors re re-thrown
-      throw error;
+      // `data` is `null`:
+      return handleSingularGraphQlError(error);
     }
   }
 }

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

@@ -21,6 +21,8 @@ import {
   initializeModel,
 } from '../APIClient';
 
+import { handleListGraphQlError } from './utils';
+
 export interface IndexMeta {
   queryField: string;
   pk: string;
@@ -97,16 +99,6 @@ function processGraphQlResponse(
   };
 }
 
-function handleGraphQlError(error: any) {
-  if (error.errors) {
-    // graphql errors pass through
-    return error as any;
-  } else {
-    // non-graphql errors re re-thrown
-    throw error;
-  }
-}
-
 async function _indexQuery(
   client: BaseClient,
   modelIntrospection: ModelIntrospectionSchema,
@@ -173,6 +165,46 @@ async function _indexQuery(
       );
     }
   } catch (error: any) {
-    return handleGraphQlError(error);
+    /**
+     * 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 = flattenItems(data)[key];
+
+        /**
+         * 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);
+    }
   }
 }

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

@@ -22,6 +22,8 @@ import {
   initializeModel,
 } from '../APIClient';
 
+import { handleListGraphQlError } from './utils';
+
 export function listFactory(
   client: BaseClient,
   modelIntrospection: ModelIntrospectionSchema,
@@ -68,9 +70,9 @@ async function _list(
     modelIntrospection,
   );
 
-  try {
-    const auth = authModeParams(client, getInternals, args);
+  const auth = authModeParams(client, getInternals, args);
 
+  try {
     const headers = getCustomHeaders(client, getInternals, args?.headers);
 
     const { data, extensions } = contextSpec
@@ -132,12 +134,66 @@ async function _list(
       };
     }
   } catch (error: any) {
-    if (error.errors) {
-      // graphql errors pass through
-      return error as 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 && Object.keys(data).length !== 0 && errors) {
+      const [key] = Object.keys(data);
+
+      if (data[key]?.items) {
+        const flattenedResult = flattenItems(data)[key];
+
+        /**
+         * 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 {
-      // non-graphql errors re re-thrown
-      throw error;
+      // `data` is `null` or an empty object:
+      return handleListGraphQlError(error);
     }
   }
 }

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

@@ -0,0 +1,35 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+// import { GraphQLFormattedError } from '@aws-amplify/data-schema-types';
+
+/**
+ * Handle errors for list return types (list and index query operations)
+ */
+export function handleListGraphQlError(error: any) {
+  if (error?.errors) {
+    // graphql errors pass through
+    return {
+      ...error,
+      data: [],
+    } as any;
+  } else {
+    // non-graphql errors are re-thrown
+    throw error;
+  }
+}
+
+/**
+ * Handle errors for singular return types (create, get, update, delete operations)
+ */
+export function handleSingularGraphQlError(error: any) {
+  if (error.errors) {
+    // graphql errors pass through
+    return {
+      ...error,
+      data: null,
+    } as any;
+  } else {
+    // non-graphql errors are re-thrown
+    throw error;
+  }
+}