@aws-amplify/data-schema 1.1.5 → 1.2.0

package/src/EnumType.ts

@@ -1,36 +1,30 @@
-import { Brand } from './util';
+import type { brandSymbol } from './util/Brand.js';
 
-type EnumTypeData = {
-  type: 'enum';
-  values: readonly string[];
-};
-
-export type EnumTypeParamShape = {
-  type: 'enum';
-  values: readonly string[];
-};
+type EnumTypeParamShape<values extends readonly string[] = readonly string[]> =
+  {
+    type: 'enum';
+    values: values;
+  };
 
-export type EnumType<T extends EnumTypeParamShape> = T & Brand<'enum'>;
+export interface EnumType<values extends readonly string[] = readonly string[]>
+  extends EnumTypeParamShape<values> {
+  [brandSymbol]: 'enum';
+}
 
-function _enum<T extends EnumTypeParamShape>(values: T['values']) {
-  const data: EnumTypeData = {
+function _enum<values extends readonly string[]>(values: values) {
+  const data: EnumTypeParamShape = {
     type: 'enum',
     values,
   };
 
-  return data as EnumType<T>;
+  return data as EnumType<values>;
 }
 
-type EnumTypeArgFactory<Values extends readonly string[]> = {
-  type: 'enum';
-  values: Values;
-};
-
 /**
  * this type param pattern allows us to infer literal type values from the array without using the `as const` suffix
  */
-export function enumType<Value extends string, T extends readonly Value[]>(
-  values: T,
+export function enumType<const values extends readonly string[]>(
+  values: values,
 ) {
-  return _enum<EnumTypeArgFactory<T>>(values);
+  return _enum(values);
 }

package/src/MappedTypes/CustomOperations.ts

@@ -4,7 +4,7 @@ import type {
   CustomOperation,
   CustomOperationParamShape,
 } from '../CustomOperation';
-import type { ModelField } from '../ModelField';
+import type { BaseModelField } from '../ModelField';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type {
   ResolveFieldRequirements,
@@ -66,10 +66,8 @@ export type CustomOpArguments<Shape extends CustomOperationParamShape> =
   Shape['arguments'] extends null
     ? never
     : ResolveFieldRequirements<{
-        [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends ModelField<
-          infer R,
-          any,
-          any
+        [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends BaseModelField<
+          infer R
         >
           ? R
           : never;
@@ -101,7 +99,7 @@ export type CustomOpReturnType<
           NonModelTypes,
           CustomOperations
         >
-    : Shape['returnType'] extends ModelField<infer R, any, any>
+    : Shape['returnType'] extends BaseModelField<infer R>
       ? R
       : Shape['returnType'] extends CustomType<infer R>
         ?

package/src/MappedTypes/ExtractNonModelTypes.ts

@@ -1,6 +1,6 @@
 import type { UnionToIntersection } from '@aws-amplify/data-schema-types';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type {
   SchemaTypes,
   ModelAndCustomTypes,
@@ -9,7 +9,7 @@ import type {
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
 
 export type NonModelTypesShape = {
-  enums: Record<string, EnumType<any>>;
+  enums: Record<string, any>;
   customTypes: Record<string, any>;
 };
 
@@ -51,43 +51,44 @@ export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<
 export type ExtractAndFlattenImplicitNonModelTypesFromFields<
   ParentTypeName extends string,
   Fields,
-> = {
-  // loop through the fields - omit the field that's not a non-model type
-  [FieldProp in keyof Fields as Fields[FieldProp] extends
-    | EnumType<EnumTypeParamShape>
-    | CustomType<CustomTypeParamShape>
-    ? FieldProp
-    : never]: (
-    x: NonNullable<Fields[FieldProp]> extends infer FieldType
-      ? // if the filed is a enum extract it as is
-        FieldType extends EnumType<EnumTypeParamShape>
-        ? {
-            [Key in `${ParentTypeName}${Capitalize<
-              FieldProp & string
-            >}`]: Fields[FieldProp];
-          }
-        : // if the field is a CustomType
-          FieldType extends CustomType<
-              infer CustomTypeShape extends CustomTypeParamShape
-            >
-          ? // recursively extract to the Nested CustomType, and return the
-            // merge of the current CustomType and the extracted (if any)
-            ExtractAndFlattenImplicitNonModelTypesFromFields<
-              `${ParentTypeName}${Capitalize<FieldProp & string>}`,
-              CustomTypeShape['fields']
-            > & {
+> =
+  {
+    // loop through the fields - omit the field that's not a non-model type
+    [FieldProp in keyof Fields as Fields[FieldProp] extends
+      | EnumType
+      | CustomType<CustomTypeParamShape>
+      ? FieldProp
+      : never]: (
+      x: NonNullable<Fields[FieldProp]> extends infer FieldType
+        ? // if the filed is a enum extract it as is
+          FieldType extends EnumType
+          ? {
               [Key in `${ParentTypeName}${Capitalize<
                 FieldProp & string
               >}`]: Fields[FieldProp];
             }
-          : never
-      : never,
-  ) => void;
-} extends Record<string, infer Func>
-  ? Func extends (x: infer P) => void
-    ? P // extract the union of all types of the `x` param used above
-    : Record<never, never> // return an empty mapped object (nothing got extracted)
-  : Record<never, never>; // return an empty mapped object (nothing got extracted)
+          : // if the field is a CustomType
+            FieldType extends CustomType<
+                infer CustomTypeShape extends CustomTypeParamShape
+              >
+            ? // recursively extract to the Nested CustomType, and return the
+              // merge of the current CustomType and the extracted (if any)
+              ExtractAndFlattenImplicitNonModelTypesFromFields<
+                `${ParentTypeName}${Capitalize<FieldProp & string>}`,
+                CustomTypeShape['fields']
+              > & {
+                [Key in `${ParentTypeName}${Capitalize<
+                  FieldProp & string
+                >}`]: Fields[FieldProp];
+              }
+            : never
+        : never,
+    ) => void;
+  } extends Record<string, infer Func>
+    ? Func extends (x: infer P) => void
+      ? P // extract the union of all types of the `x` param used above
+      : Record<never, never> // return an empty mapped object (nothing got extracted)
+    : Record<never, never>; // return an empty mapped object (nothing got extracted)
 
 /**
  * Pulls out implicit, i.e. field-level non-model types from `ModelType` and
@@ -129,12 +130,10 @@ type ResolveNonModelTypes<
   ResolvedSchema = SchemaTypes<Schema> & Extracted,
 > = {
   enums: {
-    [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType<EnumTypeParamShape>
+    [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType
       ? Model
-      : never]: ResolvedSchema[Model] extends EnumType<
-      infer R extends EnumTypeParamShape
-    >
-      ? R['values'][number]
+      : never]: ResolvedSchema[Model] extends EnumType<infer values>
+      ? values[number]
       : never;
   };
   customTypes: {

package/src/MappedTypes/ResolveFieldProperties.ts

@@ -20,7 +20,7 @@ import type { RefType, RefTypeParamShape } from '../RefType';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type {
   CustomOperation,
   CustomOperationParamShape,
@@ -214,7 +214,7 @@ type Intersection<
 // TODO: this should probably happen in InjectImplicitModelFields instead. Keeping here for now to reduce refactor
 // blast radius
 export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
-  [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape>
+  [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType
     ? never
     : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape>
       ? never

package/src/MappedTypes/ResolveSchema.ts

@@ -5,9 +5,9 @@ import type {
   ModelRelationshipTypes,
   RelationTypeFunctionOmitMapping,
 } from '../ModelRelationalField';
-import type { ModelField } from '../ModelField';
+import type { BaseModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
-import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { EnumType } from '../EnumType';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type {
   CustomOperation,
@@ -17,9 +17,8 @@ import type {
 export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
 
 // TODO: find better name
-export type SchemaTypes<T> = T extends GenericModelSchema<any>
-  ? T['data']['types']
-  : never;
+export type SchemaTypes<T> =
+  T extends GenericModelSchema<any> ? T['data']['types'] : never;
 
 /**
  * Resolves model types
@@ -30,7 +29,7 @@ export type SchemaTypes<T> = T extends GenericModelSchema<any>
  */
 export type ModelTypes<Schema> = {
   [Model in keyof Schema as Schema[Model] extends
-    | EnumType<EnumTypeParamShape>
+    | EnumType
     | CustomType<CustomTypeParamShape>
     | CustomOperation<CustomOperationParamShape, any>
     ? never
@@ -45,14 +44,16 @@ export type ModelTypes<Schema> = {
  */
 export type ModelAndCustomTypes<Schema> = {
   [Model in keyof Schema as Schema[Model] extends
-    | EnumType<EnumTypeParamShape>
+    | EnumType
     | CustomOperation<CustomOperationParamShape, any>
     ? never
-    : Model]: Schema[Model] extends ModelType<any, any>
+    : // TODO: This should use BaseModel, but seems to only work because it relies on
+      // omitting extra methods
+      Model]: Schema[Model] extends
+    | ModelType<any, any>
+    | CustomType<CustomTypeParamShape>
     ? Schema[Model]
-    : Schema[Model] extends CustomType<CustomTypeParamShape>
-      ? Schema[Model]
-      : never;
+    : never;
 };
 
 /**
@@ -62,11 +63,9 @@ export type ModelAndCustomTypes<Schema> = {
  */
 export type FieldTypes<T> = {
   [ModelProp in keyof T]: {
-    [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends ModelField<
+    [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends BaseModelField<
       // Match the most common field type to improve resolving performance
-      infer R,
-      any,
-      any
+      infer R
     >
       ? R
       : T[ModelProp][FieldProp] extends RefType<
@@ -80,7 +79,7 @@ export type FieldTypes<T> = {
           : T[ModelProp][FieldProp] | null
         : // replace non-model types with Ref
           T[ModelProp][FieldProp] extends
-              | EnumType<EnumTypeParamShape>
+              | EnumType
               | CustomType<CustomTypeParamShape>
           ? RefType<{
               link: `${Capitalize<ModelProp & string>}${Capitalize<
@@ -114,10 +113,8 @@ export type FieldTypes<T> = {
  */
 export type FieldTypesOfCustomType<T> = {
   [CustomTypeName in keyof T]: {
-    [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends ModelField<
-      infer R,
-      any,
-      any
+    [FieldProp in keyof T[CustomTypeName]]: T[CustomTypeName][FieldProp] extends BaseModelField<
+      infer R
     >
       ? R
       : T[CustomTypeName][FieldProp] extends RefType<
@@ -131,7 +128,7 @@ export type FieldTypesOfCustomType<T> = {
           : T[CustomTypeName][FieldProp] | null
         : // replace non-model types with Ref
           T[CustomTypeName][FieldProp] extends
-              | EnumType<EnumTypeParamShape>
+              | EnumType
               | CustomType<CustomTypeParamShape>
           ? RefType<{
               link: `${Capitalize<CustomTypeName & string>}${Capitalize<

package/src/ModelField.ts

@@ -1,5 +1,7 @@
-import { Brand, brand } from './util';
+import { brand } from './util';
 import { AllowModifier, Authorization, allow } from './Authorization';
+import type { methodKeyOf, satisfy } from './util/usedMethods.js';
+import type { brandSymbol } from './util/Brand.js';
 
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
@@ -34,7 +36,7 @@ export enum ModelFieldDataType {
 }
 
 type FieldMeta = {
-  lastInvokedMethod: null | keyof ModelField<ModelFieldTypeParamOuter>;
+  lastInvokedMethod: null | methodKeyOf<ModelField>;
 };
 
 type FieldData = {
@@ -67,56 +69,69 @@ export type ArrayField<T> = [T] extends [ModelFieldTypeParamInner]
   ? Array<T> | null // optional by default
   : never;
 
+export type BaseModelField<
+  T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter,
+> = ModelField<T, UsableModelFieldKey, any>;
+
+export type UsableModelFieldKey = satisfy<
+  methodKeyOf<ModelField>,
+  'required' | 'default' | 'authorization'
+>;
+
 /**
  * Public API for the chainable builder methods exposed by Model Field.
  * The type is narrowing e.g., after calling .array() it will be omitted from intellisense suggestions
  *
  * @typeParam T - holds the JS data type of the field
- * @typeParam K - union of strings representing already-invoked method names. Used to improve Intellisense
+ * @typeParam UsedMethod - union of strings representing already-invoked method names. Used to improve Intellisense
  */
 export type ModelField<
-  T extends ModelFieldTypeParamOuter,
-  // rename K
-  K extends keyof ModelField<T> = never,
+  T extends ModelFieldTypeParamOuter = ModelFieldTypeParamOuter,
+  UsedMethod extends UsableModelFieldKey = never,
   Auth = undefined,
 > = Omit<
   {
+    // This is a lie. This property is never set at runtime. It's just used to smuggle auth types through.
+    [__auth]?: Auth;
+    [brandSymbol]: typeof brandName;
+
     /**
      * Marks a field as required.
      */
-    required(): ModelField<Required<T>, K | 'required'>;
+    required(): ModelField<Required<T>, UsedMethod | 'required'>;
     // Exclude `optional` after calling array, because both the value and the array itself can be optional
     /**
      * Converts a field type definition to an array of the field type.
      */
-    array(): ModelField<ArrayField<T>, Exclude<K, 'required'> | 'array'>;
+    array(): ModelField<ArrayField<T>, Exclude<UsedMethod, 'required'>>;
     // TODO: should be T, but .array breaks this constraint. Fix later
     /**
      * Sets a default value for the scalar type.
      * @param value the default value
      */
-    default(value: ModelFieldTypeParamOuter): ModelField<T, K | 'default'>;
+    default(
+      value: ModelFieldTypeParamOuter,
+    ): ModelField<T, UsedMethod | 'default'>;
     /**
      * Configures field-level authorization rules. Pass in an array of authorizations `(allow => allow.____)` to mix and match
      * multiple authorization rules for this field.
      */
     authorization<AuthRuleType extends Authorization<any, any, any>>(
-      callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[],
-    ): ModelField<T, K | 'authorization', AuthRuleType>;
+      callback: (
+        allow: Omit<AllowModifier, 'resource'>,
+      ) => AuthRuleType | AuthRuleType[],
+    ): ModelField<T, UsedMethod | 'authorization', AuthRuleType>;
   },
-  K
-> & {
-  // This is a lie. This property is never set at runtime. It's just used to smuggle auth types through.
-  [__auth]?: Auth;
-} & Brand<typeof brandName>;
+  UsedMethod
+>;
 
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.
  */
-export type InternalField = ModelField<ModelFieldTypeParamOuter, never> & {
+export interface InternalField extends ModelField {
   data: FieldData;
-};
+}
 
 /**
  * Model Field Implementation

package/src/ModelSchema.ts

@@ -7,14 +7,13 @@ import type {
   UnionToIntersection,
 } from '@aws-amplify/data-schema-types';
 import {
-  type ModelType,
-  type ModelTypeParamShape,
   type InternalModel,
   isSchemaModelType,
   SchemaModelType,
   AddRelationshipFieldsToModelTypeFields,
+  type BaseModelType,
 } from './ModelType';
-import type { EnumType, EnumTypeParamShape } from './EnumType';
+import type { EnumType } from './EnumType';
 import type { CustomType, CustomTypeParamShape } from './CustomType';
 import type {
   CustomOperation,
@@ -26,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,
@@ -41,11 +40,15 @@ const ddbSchemaBrand = brand(ddbSchemaBrandName);
 export type DDBSchemaBrand = Brand<typeof ddbSchemaBrandName>;
 
 type SchemaContent =
-  | ModelType<ModelTypeParamShape, any>
+  | BaseModelType
   | CustomType<CustomTypeParamShape>
-  | EnumType<EnumTypeParamShape>
+  | 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>;
@@ -76,10 +79,7 @@ export type BaseSchema<
 > = {
   data: T;
   models: {
-    [TypeKey in keyof T['types']]: T['types'][TypeKey] extends ModelType<
-      ModelTypeParamShape,
-      never | 'identifier'
-    >
+    [TypeKey in keyof T['types']]: T['types'][TypeKey] extends BaseModelType
       ? SchemaModelType<T['types'][TypeKey], TypeKey & string, IsRDS>
       : never;
   };
@@ -107,6 +107,7 @@ export type ModelSchema<
   DDBSchemaBrand;
 
 type RDSModelSchemaFunctions =
+  | 'addToSchema'
   | 'addQueries'
   | 'addMutations'
   | 'addSubscriptions'
@@ -128,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>,
     >(
@@ -258,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>,
@@ -282,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;
@@ -334,7 +372,7 @@ function _rdsSchema<
         models[newName] = currentType;
         data.types[newName] = currentType;
         models[newName].data.originalName = curName;
-        
+
         delete models[curName];
         delete data.types[curName];
       });
@@ -348,7 +386,7 @@ function _rdsSchema<
 function _ddbSchema<
   T extends ModelSchemaParamShape,
   DSC extends SchemaConfiguration<any, any>,
->(types: T['types'], config: DSC) {
+>(types: T['types'], config: DSC): ModelSchema<T> {
   const data: ModelSchemaParamShape = {
     types,
     authorization: [],
@@ -369,7 +407,7 @@ function _ddbSchema<
     },
     models: filterSchemaModelTypes(data.types),
     ...ddbSchemaBrand,
-  } as ModelSchema<T>;
+  } satisfies ModelSchema<any> as never;
 }
 
 type SchemaReturnType<