@aws-amplify/data-schema 0.16.2 → 0.17.1

package/package.json

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

package/src/MappedTypes/MapSecondaryIndexes.ts

@@ -1,4 +1,3 @@
-import { IsEmptyStringOrNever } from '@aws-amplify/data-schema-types';
 import { ModelIndexType } from '../ModelIndex';
 
 type ModelIndexTypeShape = ModelIndexType<any, any, any, any, any>;
@@ -34,31 +33,28 @@ export type SecondaryIndexToIR<
  *
  * @remarks - the IR type alias is defined as SecondaryIndexIrShape in data-schema-types
  */
-type SingleIndexIrFromType<
-  Idx extends ModelIndexTypeShape,
-  ResolvedFields,
-> = Idx extends ModelIndexType<
-  any,
-  infer PK extends string,
-  infer SK,
-  infer QueryField extends string | never,
-  any
->
-  ? {
-      queryField: IsEmptyStringOrNever<QueryField> extends true
-        ? `listBy${QueryFieldLabelFromTuple<SK, Capitalize<PK>>}`
-        : QueryField;
-      pk: PK extends keyof ResolvedFields
-        ? {
-            [Key in PK]: Exclude<ResolvedFields[PK], null>;
-          }
-        : never;
-      // distribute ResolvedFields over SK
-      sk: unknown extends SK
-        ? never
-        : ResolvedSortKeyFields<SK, ResolvedFields>;
-    }
-  : never;
+type SingleIndexIrFromType<Idx extends ModelIndexTypeShape, ResolvedFields> =
+  Idx extends ModelIndexType<
+    any,
+    infer PK extends string,
+    infer SK,
+    infer QueryField extends string | never,
+    any
+  >
+    ? {
+        defaultQueryFieldSuffix: `${QueryFieldLabelFromTuple<SK, Capitalize<PK>>}`;
+        queryField: QueryField;
+        pk: PK extends keyof ResolvedFields
+          ? {
+              [Key in PK]: Exclude<ResolvedFields[PK], null>;
+            }
+          : never;
+        // distribute ResolvedFields over SK
+        sk: unknown extends SK
+          ? never
+          : ResolvedSortKeyFields<SK, ResolvedFields>;
+      }
+    : never;
 
 /**
  * @typeParam SK - tuple of SortKey field names, e.g. ['viewCount', 'createdAt']

package/src/SchemaProcessor.ts

@@ -810,12 +810,13 @@ type TransformedSecondaryIndexes = {
  * @returns default query field name
  */
 const secondaryIndexDefaultQueryField = (
+  modelName: string,
   pk: string,
   sk?: readonly string[],
 ): string => {
   const skName = sk?.length ? 'And' + sk?.map(capitalize).join('And') : '';
 
-  const queryField = `listBy${capitalize(pk)}${skName}`;
+  const queryField = `list${capitalize(modelName)}By${capitalize(pk)}${skName}`;
 
   return queryField;
 };
@@ -825,6 +826,7 @@ const secondaryIndexDefaultQueryField = (
  * and the value is an array of transformed Amplify @index directives with all supplied attributes
  */
 const transformedSecondaryIndexesForModel = (
+  modelName: string,
   secondaryIndexes: readonly InternalModelIndexType[],
 ): TransformedSecondaryIndexes => {
   const indexDirectiveWithAttributes = (
@@ -835,6 +837,7 @@ const transformedSecondaryIndexesForModel = (
   ): string => {
     if (!sortKeys.length && !indexName && !queryField) {
       return `@index(queryField: "${secondaryIndexDefaultQueryField(
+        modelName,
         partitionKey,
       )}")`;
     }
@@ -856,6 +859,7 @@ const transformedSecondaryIndexesForModel = (
     } else {
       attributes.push(
         `queryField: "${secondaryIndexDefaultQueryField(
+          modelName,
           partitionKey,
           sortKeys,
         )}"`,
@@ -1164,6 +1168,7 @@ const schemaPreprocessor = (
       const [partitionKey] = identifier;
 
       const transformedSecondaryIndexes = transformedSecondaryIndexesForModel(
+        typeName,
         typeDef.data.secondaryIndexes,
       );
 

package/src/runtime/client/index.ts

@@ -8,6 +8,7 @@ import {
   Equal,
   __modelMeta__,
   ExtractModelMeta,
+  IsEmptyStringOrNever,
 } from '@aws-amplify/data-schema-types';
 import type { Observable } from 'rxjs';
 
@@ -494,10 +495,11 @@ type ModelMetaShape = {
 
 // TODO: remove export. added for debugging.
 export type ModelTypesClient<
+  ModelName extends string,
   Model extends Record<string, unknown>,
   ModelMeta extends ModelMetaShape,
   FlatModel extends Record<string, unknown> = ResolvedModel<Model>,
-> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], Model> & {
+> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], ModelName, Model> & {
   create: (
     model: Prettify<CreateModelInput<Model, ModelMeta>>,
     options?: {
@@ -589,10 +591,11 @@ export type ModelTypesClient<
 };
 
 type ModelTypesSSRCookies<
+  ModelName extends string,
   Model extends Record<string, unknown>,
   ModelMeta extends ModelMetaShape,
   FlatModel extends Record<string, unknown> = ResolvedModel<Model>,
-> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], Model> & {
+> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], ModelName, Model> & {
   create: (
     model: Prettify<CreateModelInput<Model, ModelMeta>>,
     options?: {
@@ -641,10 +644,11 @@ type ModelTypesSSRCookies<
 };
 
 type ModelTypesSSRRequest<
+  ModelName extends string,
   Model extends Record<string, unknown>,
   ModelMeta extends ModelMetaShape,
   FlatModel extends Record<string, unknown> = ResolvedModel<Model>,
-> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], Model> & {
+> = IndexQueryMethodsFromIR<ModelMeta['secondaryIndexes'], ModelName, Model> & {
   create: (
     // TODO: actual type
     contextSpec: any,
@@ -716,11 +720,19 @@ export type ModelTypes<
   >]: ModelName extends string
     ? Schema[ModelName] extends Record<string, unknown>
       ? Context extends 'CLIENT'
-        ? ModelTypesClient<Schema[ModelName], ModelMeta[ModelName]>
+        ? ModelTypesClient<ModelName, Schema[ModelName], ModelMeta[ModelName]>
         : Context extends 'COOKIES'
-          ? ModelTypesSSRCookies<Schema[ModelName], ModelMeta[ModelName]>
+          ? ModelTypesSSRCookies<
+              ModelName,
+              Schema[ModelName],
+              ModelMeta[ModelName]
+            >
           : Context extends 'REQUEST'
-            ? ModelTypesSSRRequest<Schema[ModelName], ModelMeta[ModelName]>
+            ? ModelTypesSSRRequest<
+                ModelName,
+                Schema[ModelName],
+                ModelMeta[ModelName]
+              >
             : never
       : never
     : never;
@@ -847,6 +859,7 @@ export type CustomHeaders =
  * SecondaryIndex index types and query methods
  */
 export type SecondaryIndexIrShape = {
+  defaultQueryFieldSuffix: string;
   queryField: string;
   pk: { [key: string]: string | number };
   sk: { [key: string]: string | number };
@@ -854,20 +867,30 @@ export type SecondaryIndexIrShape = {
 
 type IndexQueryMethodsFromIR<
   SecondaryIdxTuple extends SecondaryIndexIrShape[],
+  ModelName extends string,
   Model extends Record<string, unknown>,
   Res = unknown, // defaulting `unknown` because it gets absorbed in an intersection, e.g. `{a: 1} & unknown` => `{a: 1}`
 > = SecondaryIdxTuple extends [
   infer A extends SecondaryIndexIrShape,
   ...infer B extends SecondaryIndexIrShape[],
 ]
-  ? IndexQueryMethodsFromIR<B, Model, IndexQueryMethodSignature<A, Model> & Res>
+  ? IndexQueryMethodsFromIR<
+      B,
+      ModelName,
+      Model,
+      IndexQueryMethodSignature<A, ModelName, Model> & Res
+    >
   : Res;
 
 type IndexQueryMethodSignature<
   Idx extends SecondaryIndexIrShape,
+  ModelName extends string,
   Model extends Record<string, unknown>,
-> = {
-  [K in Idx['queryField'] & string]: <
+> = Record<
+  IsEmptyStringOrNever<Idx['queryField']> extends false
+    ? Idx['queryField']
+    : `list${ModelName}By${Idx['defaultQueryFieldSuffix']}`,
+  <
     FlatModel extends Record<string, unknown> = ResolvedModel<Model>,
     SelectionSet extends ReadonlyArray<ModelPath<FlatModel>> = never[],
   >(
@@ -886,8 +909,8 @@ type IndexQueryMethodSignature<
       authToken?: string;
       headers?: CustomHeaders;
     },
-  ) => ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>;
-};
+  ) => ListReturnValue<Prettify<ReturnValue<Model, FlatModel, SelectionSet>>>
+>;
 
 type FilteredKeys<T> = {
   [P in keyof T]: T[P] extends never ? never : P;

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