@aws-amplify/data-schema 1.1.6 → 1.2.1

package/src/ModelSchema.ts

@@ -25,7 +25,7 @@ import type {
 } from './CustomOperation';
 import { processSchema } from './SchemaProcessor';
 import { AllowModifier, SchemaAuthorization, allow } from './Authorization';
-import { Brand, brand } from './util';
+import { Brand, brand, getBrand } from './util';
 import {
   ModelRelationalField,
   ModelRelationalFieldParamShape,
@@ -45,6 +45,10 @@ type SchemaContent =
   | EnumType
   | CustomOperation<CustomOperationParamShape, any>;
 
+// The SQL-only `addToSchema` accepts all top-level entities, excepts models
+type AddToSchemaContent = Exclude<SchemaContent, BaseModelType>;
+type AddToSchemaContents = Record<string, AddToSchemaContent>;
+
 type NonEmpty<T> = keyof T extends never ? never : T;
 
 type ModelSchemaContents = Record<string, SchemaContent>;
@@ -103,6 +107,7 @@ export type ModelSchema<
   DDBSchemaBrand;
 
 type RDSModelSchemaFunctions =
+  | 'addToSchema'
   | 'addQueries'
   | 'addMutations'
   | 'addSubscriptions'
@@ -124,18 +129,33 @@ export type RDSModelSchema<
   >,
 > = Omit<
   {
+    addToSchema: <AddedTypes extends AddToSchemaContents>(
+      types: AddedTypes,
+    ) => RDSModelSchema<
+      SetTypeSubArg<T, 'types', T['types'] & AddedTypes>,
+      UsedMethods | 'addToSchema'
+    >;
+    /**
+     * @deprecated use `addToSchema()` to add operations to a SQL schema
+     */
     addQueries: <Queries extends Record<string, QueryCustomOperation>>(
       types: Queries,
     ) => RDSModelSchema<
       SetTypeSubArg<T, 'types', T['types'] & Queries>,
       UsedMethods | 'addQueries'
     >;
+    /**
+     * @deprecated use `addToSchema()` to add operations to a SQL schema
+     */
     addMutations: <Mutations extends Record<string, MutationCustomOperation>>(
       types: Mutations,
     ) => RDSModelSchema<
       SetTypeSubArg<T, 'types', T['types'] & Mutations>,
       UsedMethods | 'addMutations'
     >;
+    /**
+     * @deprecated use `addToSchema()` to add operations to a SQL schema
+     */
     addSubscriptions: <
       Subscriptions extends Record<string, SubscriptionCustomOperation>,
     >(
@@ -254,6 +274,22 @@ export const isModelSchema = (
   return typeof schema === 'object' && schema.data !== undefined;
 };
 
+/**
+ * Ensures that only supported entities are being added to the SQL schema through `addToSchema`
+ * Models are not supported for brownfield SQL
+ *
+ * @param types - purposely widened to ModelSchemaContents, because we need to validate at runtime that a model is not being passed in here
+ */
+function validateAddToSchema(types: ModelSchemaContents): void {
+  for (const [name, type] of Object.entries(types)) {
+    if (getBrand(type) === 'modelType') {
+      throw new Error(
+        `Invalid value specified for ${name} in addToSchema(). Models cannot be manually added to a SQL schema.`,
+      );
+    }
+  }
+}
+
 function _rdsSchema<
   T extends RDSModelSchemaParamShape,
   DSC extends SchemaConfiguration<any, any>,
@@ -278,6 +314,12 @@ function _rdsSchema<
       const { authorization: _, ...rest } = this;
       return rest;
     },
+    addToSchema(types: AddToSchemaContents): any {
+      validateAddToSchema(types);
+      this.data.types = { ...this.data.types, ...types };
+      const { addToSchema: _, ...rest } = this;
+      return rest;
+    },
     addQueries(types: Record<string, QueryCustomOperation>): any {
       this.data.types = { ...this.data.types, ...types };
       const { addQueries: _, ...rest } = this;

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/SchemaProcessor.ts

@@ -1159,8 +1159,7 @@ const schemaPreprocessor = (
       ? 'dynamodb'
       : 'sql';
 
-  const staticSchema =
-    schema.data.configuration.database.engine === 'dynamodb' ? false : true;
+  const staticSchema = databaseType === 'sql';
 
   const topLevelTypes = sortTopLevelTypes(Object.entries(schema.data.types));
 
@@ -1288,11 +1287,7 @@ const schemaPreprocessor = (
       const [partitionKey] = identifier;
 
       const { authString, authFields } = calculateAuth(mostRelevantAuthRules);
-      if (authString == '') {
-        throw new Error(
-          `Model \`${typeName}\` is missing authorization rules. Add global rules to the schema or ensure every model has its own rules.`,
-        );
-      }
+
       const fieldLevelAuthRules = processFieldLevelAuthRules(
         fields,
         authFields,

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,6 +481,53 @@ 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
@@ -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>;
+}