@aws-amplify/data-schema 1.3.5 → 1.3.7

package/package.json

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

package/src/ClientSchema/Core/ClientCustomOperations.ts

@@ -6,6 +6,7 @@ import type { AppSyncResolverHandler } from 'aws-lambda';
 import type { CustomType } from '../../CustomType';
 import type { FieldTypesOfCustomType } from '../../MappedTypes/ResolveSchema';
 import type { ResolveRef } from '../utilities/ResolveRef';
+import type { EnumType } from '../../EnumType';
 import { ClientSchemaProperty } from './ClientSchemaProperty';
 
 type CustomOperationSubType<Op extends CustomOperationParamShape> =
@@ -83,7 +84,9 @@ type CustomOpArguments<Shape extends CustomOperationParamShape> =
           infer R
         >
           ? R
-          : never;
+          : Shape['arguments'][FieldName] extends EnumType<infer Values>
+            ? Values[number] | null
+            : never;
       }>;
 
 /**

package/src/SchemaProcessor.ts

@@ -4,6 +4,7 @@ import {
   type InternalField,
   string,
   type BaseModelField,
+  ModelFieldType,
 } from './ModelField';
 import { type InternalRelationalField } from './ModelRelationalField';
 import type { InternalModel } from './ModelType';
@@ -397,14 +398,14 @@ function customOperationToGql(
   }
 
   if (Object.keys(fieldArgs).length > 0) {
-    const { gqlFields, implicitTypes } = processFields(
+    const { gqlFields, implicitTypes: implied } = processFields(
       typeName,
       fieldArgs,
       {},
       {},
     );
     callSignature += `(${gqlFields.join(', ')})`;
-    implicitTypes.push(...implicitTypes);
+    implicitTypes.push(...implied);
   }
 
   const handler = handlers && handlers[0];
@@ -484,6 +485,34 @@ function escapeGraphQlString(str: string) {
   return JSON.stringify(str);
 }
 
+/**
+ * AWS AppSync scalars that are stored as strings in the data source
+ */
+const stringFieldTypes = {
+  ID: true,
+  String: true,
+  AWSDate: true,
+  AWSTime: true,
+  AWSDateTime: true,
+  AWSEmail: true,
+  AWSPhone: true,
+  AWSURL: true,
+  AWSIPAddress: true,
+};
+
+/**
+ * Normalize string-compatible field types for comparison
+ */
+const normalizeStringFieldTypes = (
+  fieldType: ModelFieldType,
+): ModelFieldType => {
+  if (fieldType in stringFieldTypes) {
+    return ModelFieldType.String;
+  }
+
+  return fieldType;
+};
+
 /**
  * Tests whether two ModelField definitions are in conflict.
  *
@@ -496,15 +525,24 @@ function escapeGraphQlString(str: string) {
  * @returns
  */
 function areConflicting(left: BaseModelField, right: BaseModelField): boolean {
-  // These are the only props we care about for this comparison, because the others
+  const leftData = (left as InternalField).data;
+  const rightData = (right as InternalField).data;
+
+  // `array` and `fieldType` are the only props we care about for this comparison, because the others
   // (required, arrayRequired, etc) are not specified on auth or FK directives.
-  const relevantProps = ['array', 'fieldType'] as const;
-  for (const prop of relevantProps) {
-    if (
-      (left as InternalField).data[prop] !== (right as InternalField).data[prop]
-    ) {
-      return true;
-    }
+  if (leftData.array !== rightData.array) {
+    return true;
+  }
+
+  // Convert "string-compatible" field types to `String` for the sake of this comparison
+  //
+  // E.g. if a customer has an explicit a.id() field that they're referencing in an allow.ownerDefinedIn rule
+  // we treat ID and String as equivalent/non-conflicting
+  if (
+    normalizeStringFieldTypes(leftData.fieldType) !==
+    normalizeStringFieldTypes(rightData.fieldType)
+  ) {
+    return true;
   }
 
   return false;

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

@@ -191,6 +191,21 @@ function hasStringField<Field extends string>(
   return typeof o[field] === 'string';
 }
 
+/**
+ * @param argDef A single argument definition from a custom operation
+ * @returns A string naming the base type including the `!` if the arg is required.
+ */
+function argumentBaseTypeString(
+  argDef: Exclude<CustomOperation['arguments'], undefined>[number],
+) {
+  const requiredFlag = argDef.isRequired ? '!' : '';
+  if (argDef.type instanceof Object && 'enum' in argDef.type) {
+    return argDef.type.enum + requiredFlag;
+  } else {
+    return argDef.type + requiredFlag;
+  }
+}
+
 /**
  * Generates "outer" arguments string for a custom operation. For example,
  * in this operation:
@@ -216,7 +231,7 @@ function outerArguments(operation: CustomOperation): string {
   }
   const args = Object.entries(operation.arguments)
     .map(([k, v]) => {
-      const baseType = v.type + (v.isRequired ? '!' : '');
+      const baseType = argumentBaseTypeString(v);
       const finalType = v.isArray
         ? `[${baseType}]${v.isArrayNullable ? '' : '!'}`
         : baseType;
@@ -261,7 +276,7 @@ function innerArguments(operation: CustomOperation): string {
 /**
  * Generates the selection set string for a custom operation. This is slightly
  * different than the selection set generation for models. If the custom op returns
- * a primitive or enum types, it doen't require a selection set at all.
+ * a primitive or enum types, it doesn't require a selection set at all.
  *
  * E.g., the graphql might look like this:
  *