@aws-amplify/data-schema 1.2.2 → 1.2.4

package/src/runtime/internals/APIClient.ts

@@ -11,6 +11,7 @@ import {
   GraphQLAuthMode,
   ClientInternalsGetter,
   ListArgs,
+  Field,
   ModelFieldType,
   ModelIntrospectionSchema,
   NonModelFieldType,
@@ -72,32 +73,117 @@ const resolvedSkName = (sk: string[]): string => {
 };
 
 /**
+ * Crawls a model tree, starting with a given **individual** model instance record, looking
+ * for related hasMany children to extract from their `items` containers.
  *
- * @param GraphQL response object
- * @returns response object with `items` properties flattened
+ * E.g., if we have a record like this:
+ *
+ * ```js
+ * {
+ *   id: 'some-id',
+ *   children: {
+ *     items: [
+ *       { name: 'a' }
+ *       { name: 'b' }
+ *       { name: 'c' }
+ *     ]
+ *   }
+ * }
+ * ```
+ *
+ * And if `children` refers to *an array of another model* (as opposed to a custom type),
+ * the `items` will be extracted. We do this because `items` is just the mechanism for nesting
+ * child records -- we don't want customers to have to dig the items out in application code.
+ * Ultimately, we return this "flattened" structure:
+ *
+ * ```js
+ * {
+ *   id: 'some-id',
+ *   children: [
+ *     { name: 'a' }
+ *     { name: 'b' }
+ *     { name: 'c' }
+ *   ]
+ * }
+ * ```
+ *
+ * Notably, an identical record could be the result of a nested custom type that contains an
+ * `items` property. This will *not* be flattened, because in that case the `items` property is
+ * actually part of the customer's schema. Similarly if a model contains an explicit `items` field.
+ *
+ * @param modelIntrospection Top-level model introspection schema.
+ * @param modelName The name of the model. Can be `undefined`. E.g., for customOperation return types.
+ * @param modelRecord The individual "model instance record" to normalize.
  */
-export const flattenItems = (obj: Record<string, any>): Record<string, any> => {
-  const res: Record<string, any> = {};
-
-  Object.entries(obj).forEach(([prop, value]) => {
-    if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
-      if (value.items !== undefined) {
-        res[prop] = value.items.map((item: Record<string, any>) =>
-          flattenItems(item),
-        );
-
-        return;
-      }
-      res[prop] = flattenItems(value);
-
-      return;
+export const flattenItems = (
+  modelIntrospection: ModelIntrospectionSchema,
+  modelName: string | undefined,
+  modelRecord: Record<string, any>,
+): Record<string, any> | null => {
+  if (!modelRecord) return null;
+
+  const mapped = {} as Record<string, any>;
+  for (const [fieldName, value] of Object.entries(modelRecord)) {
+    const fieldDef = modelName
+      ? modelIntrospection.models[modelName]?.fields[fieldName]
+      : undefined;
+    const dvPair = { fieldDef, value };
+    if (isRelatedModelItemsArrayPair(dvPair)) {
+      mapped[fieldName] = dvPair.value.items.map((itemValue) =>
+        flattenItems(modelIntrospection, dvPair.fieldDef.type.model, itemValue),
+      );
+    } else if (isRelatedModelProperty(fieldDef)) {
+      mapped[fieldName] = flattenItems(
+        modelIntrospection,
+        fieldDef.type.model,
+        value,
+      );
+    } else {
+      mapped[fieldName] = value;
     }
+  }
+  return mapped;
+};
 
-    res[prop] = value;
-  });
+/**
+ * Determines whether the given field definition and associated result value
+ * represent a related model array from a HasMany-type relationship.
+ *
+ * @param dv Pair of field definition and associated result value
+ * @returns
+ */
+function isRelatedModelItemsArrayPair(dv: {
+  fieldDef: Field | undefined;
+  value: any;
+}): dv is {
+  fieldDef: Field & { type: ModelFieldType };
+  value: { items: Record<string, any>[] };
+} {
+  return (
+    typeof dv.fieldDef?.type === 'object' &&
+    'model' in dv.fieldDef.type &&
+    typeof dv.fieldDef.type.model === 'string' &&
+    dv.fieldDef.isArray &&
+    Array.isArray(dv.value?.items)
+  );
+}
 
-  return res;
-};
+/**
+ * Determines whether the given field definition represents a relationship
+ * to another model.
+ *
+ * @param fieldDef
+ * @returns
+ */
+function isRelatedModelProperty(
+  fieldDef: Field | undefined,
+): fieldDef is Field & { type: ModelFieldType } {
+  return (
+    typeof fieldDef?.type === 'object' &&
+    'model' in fieldDef.type &&
+    typeof fieldDef.type.model === 'string'
+  );
+}
 
 // TODO: this should accept single result to support CRUD methods; create helper for array/list
 export function initializeModel(
@@ -148,7 +234,6 @@ export function initializeModel(
       }
 
       switch (relationType) {
-        case connectionType.HAS_ONE:
         case connectionType.BELONGS_TO: {
           const sortKeyValues = relatedModelSKFieldNames.reduce(
             // TODO(Eslint): is this implementation correct?
@@ -180,7 +265,7 @@ export function initializeModel(
                 );
               }
 
-              return undefined;
+              return { data: null };
             };
           } else {
             initializedRelationalFields[fieldName] = (
@@ -199,13 +284,29 @@ export function initializeModel(
                 );
               }
 
-              return undefined;
+              return { data: null };
             };
           }
 
           break;
         }
+        case connectionType.HAS_ONE:
         case connectionType.HAS_MANY: {
+          /**
+           * If the loader is a HAS_ONE, we just need to attempt to grab the first item
+           * from the result.
+           */
+          const mapResult =
+            relationType === connectionType.HAS_ONE
+              ? (result: Record<string, any>) => {
+                  return {
+                    data: result?.data.shift() || null,
+                    errors: result.errors,
+                    extensions: result.extensions,
+                  };
+                }
+              : (result: Record<string, any>) => result;
+
           const parentPk = introModel.primaryKeyInfo.primaryKeyFieldName;
           const parentSK = introModel.primaryKeyInfo.sortKeyFieldNames;
 
@@ -238,16 +339,15 @@ export function initializeModel(
                 options?: LazyLoadOptions,
               ) => {
                 if (record[parentPk]) {
-                  return (client as any).models[relatedModelName].list(
-                    contextSpec,
-                    {
+                  return (client as any).models[relatedModelName]
+                    .list(contextSpec, {
                       filter: { and: hasManyFilter },
                       limit: options?.limit,
                       nextToken: options?.nextToken,
                       authMode: options?.authMode || authMode,
                       authToken: options?.authToken || authToken,
-                    },
-                  );
+                    })
+                    .then(mapResult);
                 }
 
                 return [];
@@ -257,13 +357,15 @@ export function initializeModel(
                 options?: LazyLoadOptions,
               ) => {
                 if (record[parentPk]) {
-                  return (client as any).models[relatedModelName].list({
-                    filter: { and: hasManyFilter },
-                    limit: options?.limit,
-                    nextToken: options?.nextToken,
-                    authMode: options?.authMode || authMode,
-                    authToken: options?.authToken || authToken,
-                  });
+                  return (client as any).models[relatedModelName]
+                    .list({
+                      filter: { and: hasManyFilter },
+                      limit: options?.limit,
+                      nextToken: options?.nextToken,
+                      authMode: options?.authMode || authMode,
+                      authToken: options?.authToken || authToken,
+                    })
+                    .then(mapResult);
                 }
 
                 return [];
@@ -289,16 +391,15 @@ export function initializeModel(
               options?: LazyLoadOptions,
             ) => {
               if (record[parentPk]) {
-                return (client as any).models[relatedModelName].list(
-                  contextSpec,
-                  {
+                return (client as any).models[relatedModelName]
+                  .list(contextSpec, {
                     filter: { and: hasManyFilter },
                     limit: options?.limit,
                     nextToken: options?.nextToken,
                     authMode: options?.authMode || authMode,
                     authToken: options?.authToken || authToken,
-                  },
-                );
+                  })
+                  .then(mapResult);
               }
 
               return [];
@@ -308,13 +409,15 @@ export function initializeModel(
               options?: LazyLoadOptions,
             ) => {
               if (record[parentPk]) {
-                return (client as any).models[relatedModelName].list({
-                  filter: { and: hasManyFilter },
-                  limit: options?.limit,
-                  nextToken: options?.nextToken,
-                  authMode: options?.authMode || authMode,
-                  authToken: options?.authToken || authToken,
-                });
+                return (client as any).models[relatedModelName]
+                  .list({
+                    filter: { and: hasManyFilter },
+                    limit: options?.limit,
+                    nextToken: options?.nextToken,
+                    authMode: options?.authMode || authMode,
+                    authToken: options?.authToken || authToken,
+                  })
+                  .then(mapResult);
               }
 
               return [];

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

@@ -20,7 +20,6 @@ import { map } from 'rxjs';
 import {
   authModeParams,
   getDefaultSelectionSetForNonModelWithIR,
-  flattenItems,
   generateSelectionSet,
   getCustomHeaders,
   initializeModel,
@@ -398,7 +397,12 @@ async function _op(
     // flatten response
     if (data) {
       const [key] = Object.keys(data);
-      const flattenedResult = flattenItems(data)[key];
+
+      // TODO: when adding support for custom selection set, flattening will need
+      // to occur recursively. For now, it's expected that related models are not
+      // present in the result. Only FK's are present. Any related model properties
+      // should be replaced with lazy loaders under the current implementation.
+      const flattenedResult = data[key];
 
       // TODO: custom selection set. current selection set is default selection set only
       // custom selection set requires data-schema-type + runtime updates above.
@@ -433,7 +437,12 @@ async function _op(
      */
     if (data && Object.keys(data).length !== 0 && errors) {
       const [key] = Object.keys(data);
-      const flattenedResult = flattenItems(data)[key];
+
+      // TODO: when adding support for custom selection set, flattening will need
+      // to occur recursively. For now, it's expected that related models are not
+      // present in the result. Only FK's are present. Any related model properties
+      // should be replaced with lazy loaders under the current implementation.
+      const flattenedResult = data[key];
 
       /**
        * `flattenedResult` could be `null` here (e.g. `data: { getPost: null }`)

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

@@ -119,9 +119,11 @@ async function _get(
     // flatten response
     if (data) {
       const [key] = Object.keys(data);
-      const flattenedResult = flattenItems(data)[key];
+      const flattenedResult = flattenItems(modelIntrospection, name, data[key]);
 
-      if (options?.selectionSet) {
+      if (flattenedResult === null) {
+        return { data: null, extensions };
+      } else if (options?.selectionSet) {
         return { data: flattenedResult, extensions };
       } else {
         // TODO: refactor to avoid destructuring here
@@ -155,7 +157,7 @@ async function _get(
      */
     if (data && Object.keys(data).length !== 0 && errors) {
       const [key] = Object.keys(data);
-      const flattenedResult = flattenItems(data)[key];
+      const flattenedResult = flattenItems(modelIntrospection, name, data[key]);
 
       /**
        * `flattenedResult` could be `null` here (e.g. `data: { getPost: null }`)

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

@@ -74,6 +74,8 @@ export function indexQueryFactory(
 }
 
 function processGraphQlResponse(
+  modelIntroSchema: ModelIntrospectionSchema,
+  modelName: string,
   result: GraphQLResult,
   selectionSet: undefined | string[],
   modelInitializer: (flattenedResult: any[]) => any[],
@@ -83,7 +85,9 @@ function processGraphQlResponse(
   const [key] = Object.keys(data);
 
   if (data[key].items) {
-    const flattenedResult = flattenItems(data)[key];
+    const flattenedResult = data[key].items.map((value: Record<string, any>) =>
+      flattenItems(modelIntroSchema, modelName, value),
+    );
 
     return {
       data: selectionSet ? flattenedResult : modelInitializer(flattenedResult),
@@ -92,6 +96,7 @@ function processGraphQlResponse(
     };
   }
 
+  // Index queries are always list queries. No `items`? No flattening needed.
   return {
     data: data[key],
     nextToken: data[key].nextToken,
@@ -159,6 +164,8 @@ async function _indexQuery(
 
     if (response.data !== undefined) {
       return processGraphQlResponse(
+        modelIntrospection,
+        name,
         response,
         args?.selectionSet,
         modelInitializer,
@@ -181,7 +188,10 @@ async function _indexQuery(
       const [key] = Object.keys(data);
 
       if (data[key]?.items) {
-        const flattenedResult = flattenItems(data)[key];
+        const flattenedResult = data[key]?.items.map(
+          (value: Record<string, any>) =>
+            flattenItems(modelIntrospection, name, value),
+        );
 
         /**
          * Check exists since `flattenedResult` could be `null`.

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

@@ -99,7 +99,10 @@ async function _list(
       const [key] = Object.keys(data);
 
       if (data[key].items) {
-        const flattenedResult = flattenItems(data)[key];
+        const flattenedResult = data[key].items.map(
+          (value: Record<string, any>) =>
+            flattenItems(modelIntrospection, name, value),
+        );
 
         // don't init if custom selection set
         if (args?.selectionSet) {
@@ -153,7 +156,10 @@ async function _list(
       const [key] = Object.keys(data);
 
       if (data[key]?.items) {
-        const flattenedResult = flattenItems(data)[key];
+        const flattenedResult = data[key].items.map(
+          (value: Record<string, any>) =>
+            flattenItems(modelIntrospection, name, value),
+        );
 
         /**
          * Check exists since `flattenedResult` could be `null`.

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

@@ -59,6 +59,7 @@ export function subscriptionFactory(
     return observable.pipe(
       map((value) => {
         const [key] = Object.keys(value.data);
+        // Will need flattening here if/when custom selection set support is added:
         const data = (value.data as any)[key];
         const [initialized] = initializeModel(
           client,