@aws-amplify/data-schema 0.16.1 → 0.17.0

package/package.json

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

package/src/MappedTypes/CustomOperations.ts

@@ -7,7 +7,7 @@ import type {
 import type { ModelField } from '../ModelField';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type {
-  ResolveCustomTypeFieldsRequirements,
+  ResolveFieldRequirements,
   ResolveRefsOfCustomType,
   ResolveRefValueArrayTraits,
 } from './ResolveFieldProperties';
@@ -66,7 +66,7 @@ export type CustomOpShapes<Schema extends GenericModelSchema<any>> = {
 export type CustomOpArguments<Shape extends CustomOperationParamShape> =
   Shape['arguments'] extends null
     ? never
-    : {
+    : ResolveFieldRequirements<{
         [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends ModelField<
           infer R,
           any,
@@ -74,7 +74,7 @@ export type CustomOpArguments<Shape extends CustomOperationParamShape> =
         >
           ? R
           : never;
-      };
+      }>;
 
 /**
  * Computes the return type from the `returnType` of a custom operation shape.
@@ -106,12 +106,12 @@ export type CustomOpReturnType<
       ? R
       : Shape['returnType'] extends CustomType<infer R>
         ?
-            | ResolveCustomTypeFieldsRequirements<
+            | ResolveFieldRequirements<
                 FieldTypesOfCustomType<{
                   thisCustomType: R['fields'];
                 }>['thisCustomType']
               > // The inline `.customType()` with a custom operation doesn't have
-              // `.required()` modifier, hence it's nullable
+            // `.required()` modifier, hence it's nullable
             | null
         : never;
 
@@ -237,20 +237,21 @@ export type CustomOperationHandlerTypes<
  *
  * (Custom handlers should not return lazy loaded fields -- they're *lazy loaded*.)
  */
-type LambdaReturnType<T> = T extends Record<string, any>
-  ? {
-      // Return type can include `null | undefined`, which we can't meaningfully
-      // map over.
-      [K in keyof Exclude<T, null | undefined> as Exclude<
-        T,
-        null | undefined
-      >[K] extends (...args: any) => any
-        ? never
-        : K]: Exclude<T, null | undefined>[K];
-    }
-  :
-      | T
-      // If the original return type allowed null | undefined, mix them back into
-      // the final return type
-      | (null extends T ? null : never)
-      | (undefined extends T ? undefined : never);
+type LambdaReturnType<T> =
+  T extends Record<string, any>
+    ? {
+        // Return type can include `null | undefined`, which we can't meaningfully
+        // map over.
+        [K in keyof Exclude<T, null | undefined> as Exclude<
+          T,
+          null | undefined
+        >[K] extends (...args: any) => any
+          ? never
+          : K]: Exclude<T, null | undefined>[K];
+      }
+    :
+        | T
+        // If the original return type allowed null | undefined, mix them back into
+        // the final return type
+        | (null extends T ? null : never)
+        | (undefined extends T ? undefined : never);

package/src/MappedTypes/ResolveFieldProperties.ts

@@ -138,10 +138,10 @@ export type ResolveRefsOfCustomType<
     ? ResolveRef<NonModelTypes, R>
     : T[Prop];
 } extends infer Resolved
-  ? ResolveCustomTypeFieldsRequirements<Resolved>
+  ? ResolveFieldRequirements<Resolved>
   : never;
 
-export type ResolveCustomTypeFieldsRequirements<Resolved> = Intersection<
+export type ResolveFieldRequirements<Resolved> = Intersection<
   ExtractNullableFieldsToOptionalFields<Resolved>,
   ExtractNonNullableFieldsToRequiredFields<Resolved>
 >;

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;
+  }
+}