@aws-amplify/data-schema 1.2.0 → 1.2.2

package/src/ModelType.ts

@@ -363,7 +363,7 @@ export function model<T extends ModelFields>(
   fields: T,
 ): ModelType<{
   fields: T;
-  identifier: { pk: { id: string }; sk: never };
+  identifier: { pk: { id: string }; sk: never; compositeSk: never };
   secondaryIndexes: [];
   authorization: [];
 }> {

package/src/runtime/client/index.ts

@@ -449,7 +449,7 @@ type SizeFilter = {
 /**
  * Filters options that can be used on string-like fields.
  */
-type StringFilter<T extends string = string> = {
+export type StringFilter<T extends string = string> = {
   attributeExists?: boolean;
   beginsWith?: string;
   between?: [string, string];
@@ -464,7 +464,7 @@ type StringFilter<T extends string = string> = {
   size?: SizeFilter;
 };
 
-type NumericFilter = {
+export type NumericFilter = {
   attributeExists?: boolean;
   between?: [number, number];
   eq?: number;
@@ -481,12 +481,59 @@ type BooleanFilters = {
   ne?: boolean;
 };
 
+/**
+ * A composite SK (in an identifier or secondaryIndex) resolves to this type for
+ * list queries and index queries
+ * 
+ * @example
+ * Given
+ * ```ts
+ * MyModel: a
+  .model({
+    pk: a.string().required(),
+    sk1: a.string().required(),
+    sk2: a.integer().required(),
+  })
+  .identifier(['pk', 'sk1', 'sk2']),
+ * ``` 
+ * Expected list options: 
+ * ```ts
+ * {
+ *   pk?: string
+ *   sk1Sk2?: ModelPrimaryCompositeKeyConditionInput
+ * }
+ * ```
+ * Where ModelPrimaryCompositeKeyConditionInput resolves to:
+ * ```ts
+ * {
+ *   eq: {sk1: string; sk2: number};
+ *   le: {sk1: string; sk2: number};
+ *   lt: {sk1: string; sk2: number};
+ *   ge: {sk1: string; sk2: number};
+ *   gt: {sk1: string; sk2: number};
+ *   between: [ {sk1: string; sk2: number} ];
+ *   beginsWith: {sk1: string; sk2: number};
+ * }
+ * ```
+ * */
+export type ModelPrimaryCompositeKeyInput<
+  SkIr extends Record<string, string | number>,
+> = {
+  eq?: SkIr;
+  le?: SkIr;
+  lt?: SkIr;
+  ge?: SkIr;
+  gt?: SkIr;
+  between?: [SkIr];
+  beginsWith?: SkIr;
+};
+
 type ModelFilter<Model extends Record<any, any>> = LogicalFilters<Model> & {
   [K in keyof Model as Model[K] extends LazyLoader<any, any>
     ? never
-    : K]?: Model[K] extends boolean
+    : K]?: boolean extends Model[K]
     ? BooleanFilters
-    : Model[K] extends number
+    : number extends Model[K]
       ? NumericFilter
       : StringFilter;
 };
@@ -498,7 +545,6 @@ type ModelMetaShape = {
   identifier: PrimaryIndexIrShape;
 };
 
-// TODO: remove export. added for debugging.
 export type ModelTypesClient<
   ModelName extends string,
   Model extends Record<string, unknown>,
@@ -890,6 +936,7 @@ export type CustomHeaders =
 export interface PrimaryIndexIrShape {
   pk: { [key: string]: string | number };
   sk: { [key: string]: string | number } | never;
+  compositeSk: never | string;
 }
 
 /**
@@ -900,7 +947,7 @@ export interface SecondaryIndexIrShape extends PrimaryIndexIrShape {
   queryField: string;
 }
 
-type IndexQueryMethodsFromIR<
+export type IndexQueryMethodsFromIR<
   SecondaryIdxTuple extends SecondaryIndexIrShape[],
   ModelName extends string,
   Model extends Record<string, unknown>,
@@ -919,7 +966,7 @@ type IndexQueryMethodsFromIR<
     >
   : Res;
 
-type ListPkOptions<
+export type ListPkOptions<
   ModelMeta extends ModelMetaShape,
   Enums extends Record<string, string>,
 > = ModelMeta['identifier']['sk'] extends never
@@ -933,20 +980,28 @@ type ListPkOptions<
 /**
  * Accepts a PrimaryIndexIr or SecondaryIndexIr and returns resolved parameters
  */
-type IndexQueryInput<
+export type IndexQueryInput<
   Idx extends PrimaryIndexIrShape,
   Enums extends Record<string, string>,
 > = {
   [PKField in keyof Idx['pk']]: Idx['pk'][PKField] extends `${deferredRefResolvingPrefix}${infer R}`
     ? Enums[R]
     : Idx['pk'][PKField];
-} & {
-  [SKField in keyof Idx['sk']]+?: number extends Idx['sk'][SKField]
-    ? NumericFilter
-    : Idx['sk'][SKField] extends `${deferredRefResolvingPrefix}${infer R}`
-      ? StringFilter<Enums[R]>
-      : StringFilter<Idx['sk'][SKField] & string>;
-};
+} & (Idx['compositeSk'] extends never
+  ? {
+      [SKField in keyof Idx['sk']]+?: number extends Idx['sk'][SKField]
+        ? NumericFilter
+        : Idx['sk'][SKField] extends `${deferredRefResolvingPrefix}${infer R}`
+          ? StringFilter<Enums[R]>
+          : StringFilter<Idx['sk'][SKField] & string>;
+    }
+  : {
+      [CompositeSk in Idx['compositeSk']]+?: ModelPrimaryCompositeKeyInput<{
+        [SKField in keyof Idx['sk']]: Idx['sk'][SKField] extends `${deferredRefResolvingPrefix}${infer _R}`
+          ? string
+          : Idx['sk'][SKField];
+      }>;
+    });
 
 type IndexQueryMethodSignature<
   Idx extends SecondaryIndexIrShape,

package/src/runtime/internals/APIClient.ts

@@ -20,7 +20,7 @@ import {
 } from '../bridge-types';
 
 import { CustomHeaders } from '../client';
-import { resolveOwnerFields } from '../utils/resolveOwnerFields';
+import { resolveOwnerFields, capitalize } from '../utils';
 
 import type { IndexMeta } from './operations/indexQuery';
 
@@ -38,6 +38,39 @@ const connectionType = {
   BELONGS_TO: 'BELONGS_TO',
 };
 
+// When generating an SK's KeyConditionInput name, string-like types map to String
+const skGraphQlFieldTypeMap = {
+  ID: 'ID',
+  String: 'String',
+  AWSDate: 'String',
+  AWSTime: 'String',
+  AWSDateTime: 'String',
+  AWSTimestamp: 'String',
+  AWSEmail: 'String',
+  AWSPhone: 'String',
+  AWSURL: 'String',
+  AWSIPAddress: 'String',
+  AWSJSON: 'String',
+  Boolean: 'Boolean',
+  Int: 'Int',
+  Float: 'Float',
+};
+
+// move to util
+const resolvedSkName = (sk: string[]): string => {
+  if (sk.length === 1) {
+    return sk[0];
+  } else {
+    return sk.reduce((acc, curr, idx) => {
+      if (idx === 0) {
+        return curr;
+      } else {
+        return acc + capitalize(curr);
+      }
+    }, '');
+  }
+};
+
 /**
  *
  * @param GraphQL response object
@@ -676,12 +709,14 @@ export function generateGraphQLDocument(
       primaryKeyFieldName,
       sortKeyFieldNames,
     },
+    attributes,
   } = modelDefinition;
 
   // Use pascal case of the model name to generate the operations and the arguments.
   // This is required to be in sync with the resources generated by the GraphQL transformers.
   const namePascalCase = name.charAt(0).toUpperCase() + name.slice(1);
-  const pluralNamePascalCase = pluralName.charAt(0).toUpperCase() + pluralName.slice(1);
+  const pluralNamePascalCase =
+    pluralName.charAt(0).toUpperCase() + pluralName.slice(1);
 
   const { operationPrefix, usePlural } = graphQLOperationsInfo[modelOperation];
 
@@ -696,17 +731,45 @@ export function generateGraphQLDocument(
     const { queryField, pk, sk = [] } = indexMeta;
     graphQLFieldName = queryField;
 
-    const skQueryArgs = sk.reduce((acc: Record<string, any>, fieldName) => {
-      const fieldType = Object.prototype.hasOwnProperty.call(
-        fields[fieldName].type,
-        'enum',
-      )
-        ? 'String' // AppSync schema sets `ModelStringKeyConditionInput` as the type of the enum field that's used as SK
-        : fields[fieldName].type;
-      acc[fieldName] = `Model${fieldType}KeyConditionInput`;
+    /**
+     * **a. Single field SK** -> single arg where name is the field name and the type is `Model${gqlFieldType}KeyConditionInput` (nullable)
+     *  Note: string-like data types e.g.,  AWSDateTime, AWSEmail, AWSPhone, etc. should map to String. See `skGraphQlFieldTypeMap` above
+     * @example
+     * ```
+     * sk1: ModelStringKeyConditionInput
+     * ```
+     *
+     * **b. Composite SK** -> single arg where the name is camelCase concatenation of all the field names that comprise the SK
+     *  and the type is `Model${modelName}${keyAttributeName}CompositeKeyConditionInput` (nullable)
+     * @example
+     * ```
+     * sk1Sk2: ModelMyModelMyModelByPkAndSk1AndSk2CompositeKeyConditionInput
+     */
+    let skQueryArgs = {};
+
+    if (sk.length === 1) {
+      const [skField] = sk;
+      const type = (
+        typeof fields[skField].type === 'string'
+          ? fields[skField].type
+          : 'String'
+      ) as keyof typeof skGraphQlFieldTypeMap;
+      const normalizedType = skGraphQlFieldTypeMap[type];
+
+      skQueryArgs = {
+        [skField]: `Model${normalizedType}KeyConditionInput`,
+      };
+    } else if (sk.length > 1) {
+      const compositeSkArgName = resolvedSkName(sk);
+
+      const keyName = attributes?.find(
+        (attr) => attr?.properties?.queryField === queryField,
+      )?.properties?.name;
 
-      return acc;
-    }, {});
+      skQueryArgs = {
+        [compositeSkArgName]: `Model${capitalize(modelName)}${capitalize(keyName)}CompositeKeyConditionInput`,
+      };
+    }
 
     indexQueryArgs = {
       [pk]: `${
@@ -739,21 +802,69 @@ export function generateGraphQLDocument(
   };
   const listPkArgs = {};
 
+  /**
+   * Generate query field args for the SK if it's defined
+   *
+   * **1. Get queries** require each SK field to be present as a separate arg where the type is the field's GraphQL scalar type (non-nullable)
+   * @example
+   * ```
+   * sk1: String!, sk2: Int!
+   * ```
+   *
+   * **2. List queries**
+   *
+   * **a. Single field SK** -> single arg where name is the field name and the type is `Model${gqlFieldType}KeyConditionInput` (nullable)
+   *      Note: string-like data types e.g.,  AWSDateTime, AWSEmail, AWSPhone, etc. should map to String. See `skGraphQlFieldTypeMap` above
+   * @example
+   * ```
+   * sk1: ModelStringKeyConditionInput
+   * ```
+   *
+   * **b. Composite SK** -> single arg where the name is camelCase concatenation of all the field names that comprise the SK
+   *  and the type is `Model${modelName}PrimaryCompositeKeyConditionInput` (nullable)
+   * @example
+   * ```
+   * sk1Sk2: ModelMyModelPrimaryCompositeKeyConditionInput
+   * ```
+   */
   const generateSkArgs = (op: 'get' | 'list') => {
-    return sortKeyFieldNames.reduce(
-      (acc: Record<string, any>, fieldName: string) => {
-        const fieldType = fields[fieldName].type;
-
-        if (op === 'get') {
-          acc[fieldName] = `${fieldType}!`;
-        } else if (op === 'list') {
-          acc[fieldName] = `Model${fieldType}KeyConditionInput`;
-        }
+    if (sortKeyFieldNames.length === 0) return {};
 
-        return acc;
-      },
-      {},
-    );
+    if (op === 'get') {
+      return sortKeyFieldNames.reduce(
+        (acc: Record<string, any>, fieldName: string) => {
+          const fieldType = fields[fieldName].type;
+
+          if (op === 'get') {
+            acc[fieldName] = `${fieldType}!`; // ! - SK args are non-nullable in Get queries
+          }
+
+          return acc;
+        },
+        {},
+      );
+    } else {
+      // list SK
+      if (sortKeyFieldNames.length === 1) {
+        // Single SK
+        const [sk] = sortKeyFieldNames;
+        const type = (
+          typeof fields[sk].type === 'string' ? fields[sk].type : 'String'
+        ) as keyof typeof skGraphQlFieldTypeMap;
+        const normalizedType = skGraphQlFieldTypeMap[type];
+
+        return {
+          [sk]: `Model${normalizedType}KeyConditionInput`,
+        };
+      } else {
+        // Composite SK
+        const compositeSkArgName = resolvedSkName(sortKeyFieldNames);
+
+        return {
+          [compositeSkArgName]: `Model${capitalize(modelName)}PrimaryCompositeKeyConditionInput`,
+        };
+      }
+    }
   };
 
   if (isCustomPrimaryKey) {
@@ -873,6 +984,8 @@ export function buildGraphQLVariables(
     },
   } = modelDefinition;
 
+  const skName = sortKeyFieldNames?.length && resolvedSkName(sortKeyFieldNames);
+
   let variables: Record<string, any> = {};
 
   // TODO: process input
@@ -930,8 +1043,13 @@ export function buildGraphQLVariables(
       }
       if (arg?.sortDirection) {
         variables.sortDirection = arg.sortDirection;
+      }
+      if (arg && arg[primaryKeyFieldName]) {
         variables[primaryKeyFieldName] = arg[primaryKeyFieldName];
       }
+      if (skName && arg && arg[skName]) {
+        variables[skName] = arg[skName];
+      }
       if (arg?.nextToken) {
         variables.nextToken = arg.nextToken;
       }
@@ -942,10 +1060,12 @@ export function buildGraphQLVariables(
     case 'INDEX_QUERY': {
       const { pk, sk = [] } = indexMeta!;
 
+      const indexQuerySkName = sk?.length && resolvedSkName(sk);
+
       variables[pk] = arg![pk];
 
-      for (const skField of sk) {
-        variables[skField] = arg![skField];
+      if (indexQuerySkName && arg && arg[indexQuerySkName]) {
+        variables[indexQuerySkName] = arg[indexQuerySkName];
       }
 
       if (arg?.filter) {

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

@@ -144,7 +144,12 @@ async function _list(
     const { data, errors } = error;
 
     // `data` is not `null`, and is not an empty object:
-    if (data !== undefined && Object.keys(data).length !== 0 && errors) {
+    if (
+      data !== undefined &&
+      data !== null &&
+      Object.keys(data).length !== 0 &&
+      errors
+    ) {
       const [key] = Object.keys(data);
 
       if (data[key]?.items) {

package/src/runtime/utils/index.ts

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

package/src/runtime/utils/stringTransformation.ts

@@ -0,0 +1,7 @@
+/**
+ * @param s string to capitalize
+ * @returns capitalized string
+ */
+export function capitalize<T extends string>(s: T): Capitalize<T> {
+  return `${s[0].toUpperCase()}${s.slice(1)}` as Capitalize<T>;
+}