@aws-amplify/data-schema 0.13.3 → 0.13.5

package/internals/package.json

@@ -0,0 +1,6 @@
+{
+	"name": "@aws-amplify/data-schema/internals",
+	"types": "../lib-esm/src/internals/index.d.ts",
+	"main": "../lib-esm/src/internals/index.js",
+	"sideEffects": false
+}

package/lib-esm/src/CustomOperation.d.ts

@@ -1,15 +1,18 @@
-import { SetTypeSubArg, Brand } from '@aws-amplify/data-schema-types';
+import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 import { ModelField, InternalField } from './ModelField';
 import { Authorization } from './Authorization';
 import { RefType, InternalRef } from './RefType';
 import { EnumType, EnumTypeParamShape } from './EnumType';
 import { CustomType } from './CustomType';
+import { Handler } from './Handler';
 type CustomArguments = Record<string, ModelField<any, any> | EnumType<EnumTypeParamShape>>;
 type CustomReturnType = RefType<any> | CustomType<any>;
 type CustomFunctionRefType = string;
 type InternalCustomArguments = Record<string, InternalField>;
 type InternalCustomReturnType = InternalRef;
 declare const brandName = "customOperation";
+type HandlerInputType = Handler | Handler[];
 export declare const CustomOperationNames: readonly ["Query", "Mutation", "Subscription"];
 type CustomOperationName = (typeof CustomOperationNames)[number];
 type CustomData = {
@@ -18,6 +21,7 @@ type CustomData = {
     functionRef: string | null;
     authorization: Authorization<any, any, any>[];
     typeName: CustomOperationName;
+    handlers: Handler[] | null;
 };
 type InternalCustomData = CustomData & {
     arguments: InternalCustomArguments;
@@ -31,13 +35,15 @@ export type CustomOperationParamShape = {
     functionRef: string | null;
     authorization: Authorization<any, any, any>[];
     typeName: CustomOperationName;
+    handlers: Handler[] | null;
 };
 export type CustomOperation<T extends CustomOperationParamShape, K extends keyof CustomOperation<T> = never> = Omit<{
     arguments<Arguments extends CustomArguments>(args: Arguments): CustomOperation<SetTypeSubArg<T, 'arguments', Arguments>, K | 'arguments'>;
     returns<ReturnType extends CustomReturnType>(returnType: ReturnType): CustomOperation<SetTypeSubArg<T, 'returnType', ReturnType>, K | 'returns'>;
     function<FunctionRef extends CustomFunctionRefType>(functionRefOrName: FunctionRef): CustomOperation<SetTypeSubArg<T, 'functionRef', FunctionRef>, K | 'function'>;
     authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): CustomOperation<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
-}, K> & Brand<object, typeof brandName>;
+    handler(handlers: HandlerInputType): CustomOperation<SetTypeSubArg<T, 'handlers', Handler[]>, K | 'handler'>;
+}, K> & Brand<typeof brandName>;
 /**
  * Internal representation of Custom Type that exposes the `data` property.
  * Used at buildtime.
@@ -51,6 +57,7 @@ export declare function query(): CustomOperation<{
     functionRef: null;
     authorization: [];
     typeName: 'Query';
+    handlers: null;
 }>;
 export declare function mutation(): CustomOperation<{
     arguments: CustomArguments;
@@ -58,6 +65,7 @@ export declare function mutation(): CustomOperation<{
     functionRef: null;
     authorization: [];
     typeName: 'Mutation';
+    handlers: null;
 }>;
 export declare function subscription(): CustomOperation<{
     arguments: CustomArguments;
@@ -65,5 +73,6 @@ export declare function subscription(): CustomOperation<{
     functionRef: null;
     authorization: [];
     typeName: 'Subscription';
+    handlers: null;
 }>;
 export {};

package/lib-esm/src/CustomOperation.js

@@ -17,6 +17,7 @@ function _custom(typeName) {
         functionRef: null,
         authorization: [],
         typeName: typeName,
+        handlers: null,
     };
     const builder = brandedBuilder({
         arguments(args) {
@@ -35,6 +36,10 @@ function _custom(typeName) {
             data.authorization = rules;
             return this;
         },
+        handler(handlers) {
+            data.handlers = Array.isArray(handlers) ? handlers : [handlers];
+            return this;
+        },
     });
     return { ...builder, data };
 }

package/lib-esm/src/CustomType.d.ts

@@ -1,4 +1,4 @@
-import { Brand } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 import { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelField';
 /**
  * Custom Types
@@ -19,7 +19,7 @@ type InternalCustomTypeData = CustomTypeData & {
 export type CustomTypeParamShape = {
     fields: CustomTypeFields;
 };
-export type CustomType<T extends CustomTypeParamShape> = Brand<T, 'customType'>;
+export type CustomType<T extends CustomTypeParamShape> = T & Brand<'customType'>;
 /**
  * Internal representation of CustomType that exposes the `data` property.
  * Used at buildtime.

package/lib-esm/src/EnumType.d.ts

@@ -1,9 +1,9 @@
-import { Brand } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 export type EnumTypeParamShape = {
     type: 'enum';
     values: readonly string[];
 };
-export type EnumType<T extends EnumTypeParamShape> = Brand<T, 'enum'>;
+export type EnumType<T extends EnumTypeParamShape> = T & Brand<'enum'>;
 type EnumTypeArgFactory<Values extends readonly string[]> = {
     type: 'enum';
     values: Values;

package/lib-esm/src/Handler.d.ts

@@ -0,0 +1,26 @@
+import { Brand } from './util';
+declare const brandName = "Handler";
+export type Handler = Brand<typeof brandName>;
+type InlineSqlResult = {
+    sql: string;
+} & Handler;
+declare function inlineSql(sql: string): InlineSqlResult;
+type SqlReferenceResult = {
+    sqlReference: string;
+} & Handler;
+declare function sqlReference(sqlReference: string): SqlReferenceResult;
+type CustomResult = {
+    custom: string;
+} & Handler;
+declare function custom(file: string): CustomResult;
+type FunctionResult = {
+    function: (...args: any[]) => any;
+} & Handler;
+declare function fcn(fcn: (...args: any[]) => any): FunctionResult;
+export declare const handler: {
+    inlineSql: typeof inlineSql;
+    sqlReference: typeof sqlReference;
+    custom: typeof custom;
+    function: typeof fcn;
+};
+export {};

package/lib-esm/src/Handler.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const util_1 = require("./util");
+const brandName = 'Handler';
+function buildHandler() {
+    return (0, util_1.brand)(brandName);
+}
+function inlineSql(sql) {
+    return { sql, ...buildHandler() };
+}
+function sqlReference(sqlReference) {
+    return { sqlReference, ...buildHandler() };
+}
+function custom(file) {
+    return { custom: file, ...buildHandler() };
+}
+function fcn(fcn) {
+    return { function: fcn, ...buildHandler() };
+}
+exports.handler = {
+    inlineSql,
+    sqlReference,
+    custom,
+    function: fcn,
+};

package/lib-esm/src/MappedTypes/ExtractNonModelTypes.d.ts

@@ -15,7 +15,7 @@ export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModel
  */
 type ExtractImplicitNonModelTypes<Schema, ResolvedModels = ModelTypes<SchemaTypes<Schema>>> = UnionToIntersection<{
     [Model in keyof ResolvedModels]: {
-        [Field in keyof ResolvedModels[Model] as ResolvedModels[Model][Field] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? `${Capitalize<Field & string>}` : never]: ResolvedModels[Model][Field];
+        [Field in keyof ResolvedModels[Model] as ResolvedModels[Model][Field] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? `${Capitalize<Model & string>}${Capitalize<Field & string>}` : never]: ResolvedModels[Model][Field];
     };
 }[keyof ResolvedModels]>;
 type ResolveNonModelTypes<Schema, Extracted, ResolvedSchema = SchemaTypes<Schema> & Extracted> = {

package/lib-esm/src/MappedTypes/ResolveSchema.d.ts

@@ -26,7 +26,7 @@ export type ModelTypes<Schema> = {
 export type FieldTypes<T> = {
     [ModelProp in keyof T]: {
         [FieldProp in keyof T[ModelProp]]: T[ModelProp][FieldProp] extends RefType<infer R extends RefTypeParamShape, any, any> ? R['required'] extends true ? T[ModelProp][FieldProp] : T[ModelProp][FieldProp] | null : T[ModelProp][FieldProp] extends EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape> ? RefType<{
-            link: Capitalize<FieldProp & string>;
+            link: `${Capitalize<ModelProp & string>}${Capitalize<FieldProp & string>}`;
             type: 'ref';
             required: false;
             authorization: [];

package/lib-esm/src/ModelField.d.ts

@@ -1,4 +1,4 @@
-import { Brand } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 import { Authorization } from './Authorization';
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
@@ -73,7 +73,7 @@ export type ModelField<T extends ModelFieldTypeParamOuter, K extends keyof Model
     authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): ModelField<T, K | 'authorization', AuthRuleType>;
 }, K> & {
     [__auth]?: Auth;
-} & Brand<object, typeof brandName>;
+} & Brand<typeof brandName>;
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.

package/lib-esm/src/ModelField.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ipAddress = exports.url = exports.phone = exports.json = exports.email = exports.timestamp = exports.datetime = exports.time = exports.date = exports.boolean = exports.float = exports.integer = exports.string = exports.id = exports.ModelFieldDataType = exports.ModelFieldType = exports.__auth = void 0;
+const util_1 = require("./util");
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
@@ -81,6 +82,7 @@ function _field(fieldType) {
             _meta.lastInvokedMethod = 'authorization';
             return this;
         },
+        ...(0, util_1.brand)(brandName),
     };
     // this double cast gives us a Subtyping Constraint i.e., hides `data` from the public API,
     // but makes it available internally when needed

package/lib-esm/src/ModelIndex.d.ts

@@ -1,5 +1,5 @@
-import type { Brand } from '@aws-amplify/data-schema-types';
-declare const brand = "modelIndexType";
+import { Brand } from './util';
+declare const brandName = "modelIndexType";
 export type ModelIndexData = {
     partitionKey: string;
     sortKeys: readonly unknown[];
@@ -13,6 +13,6 @@ export type ModelIndexType<ModelFieldKeys extends string, PK, SK = readonly [],
     sortKeys<FieldKeys extends ModelFieldKeys = ModelFieldKeys, const SK extends ReadonlyArray<Exclude<FieldKeys, PK>> = readonly []>(sortKeys: SK): ModelIndexType<FieldKeys, PK, SK, QueryField, K | 'sortKeys'>;
     name(name: string): ModelIndexType<ModelFieldKeys, PK, SK, QueryField, K | 'name'>;
     queryField<QF extends string = never, MF extends ModelFieldKeys = ModelFieldKeys>(field: QF): ModelIndexType<MF, PK, SK, QF, K | 'queryField'>;
-}, K> & Brand<object, typeof brand>;
+}, K> & Brand<typeof brandName>;
 export declare function modelIndex<ModelFieldKeys extends string, PK extends ModelFieldKeys, SK = readonly [], QueryField = never>(partitionKeyFieldName: PK): ModelIndexType<ModelFieldKeys, PK, SK, QueryField, never>;
 export {};

package/lib-esm/src/ModelIndex.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modelIndex = void 0;
-const brand = 'modelIndexType';
+const util_1 = require("./util");
+const brandName = 'modelIndexType';
 function _modelIndex(partitionKeyFieldName) {
     const data = {
         partitionKey: partitionKeyFieldName,
@@ -22,6 +23,7 @@ function _modelIndex(partitionKeyFieldName) {
             data.queryField = field;
             return this;
         },
+        ...(0, util_1.brand)(brandName),
     };
     return { ...builder, data };
 }

package/lib-esm/src/ModelRelationalField.d.ts

@@ -1,4 +1,5 @@
-import { SetTypeSubArg, Brand } from '@aws-amplify/data-schema-types';
+import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 import { Authorization } from './Authorization';
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
@@ -60,7 +61,7 @@ type ModelRelationalFieldFunctions<T extends ModelRelationalFieldParamShape, RM
 };
 export type ModelRelationalField<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never, Auth = undefined> = Omit<ModelRelationalFieldFunctions<T, RM, K>, K> & {
     [__auth]?: Auth;
-} & Brand<object, typeof brandName>;
+} & Brand<typeof brandName>;
 /**
  * Internal representation of Model Field that exposes the `data` property.
  * Used at buildtime.

package/lib-esm/src/ModelSchema.d.ts

@@ -3,14 +3,43 @@ import { type ModelType, type ModelTypeParamShape, type InternalModel, SchemaMod
 import type { EnumType, EnumTypeParamShape } from './EnumType';
 import type { CustomType, CustomTypeParamShape } from './CustomType';
 import type { CustomOperation, CustomOperationParamShape, InternalCustom } from './CustomOperation';
-export { __auth } from './ModelField';
 import { Authorization } from './Authorization';
 type SchemaContent = ModelType<ModelTypeParamShape, any> | CustomType<CustomTypeParamShape> | EnumType<EnumTypeParamShape> | CustomOperation<CustomOperationParamShape, any>;
 type ModelSchemaContents = Record<string, SchemaContent>;
 type InternalSchemaModels = Record<string, InternalModel | EnumType<any> | CustomType<any> | InternalCustom>;
+/**
+ * Importing the full objects from @aws-amplify/plugin-types
+ * more than doubles dev env runtime. This type replacement
+ * will contain the content for config without the negative
+ * side-effects. We may need to re-approach if customers interact
+ * with these programmatically to avoid forcing narrowing.
+ */
+type BackendSecret = {
+    resolve: (scope: any, backendIdentifier: any) => any;
+    resolvePath: (backendIdentifier: any) => any;
+};
+export type DatasourceEngine = 'mysql' | 'postgresql' | 'dynamodb';
+type DatasourceConfig<DE extends DatasourceEngine> = DE extends 'dynamodb' ? {
+    engine: DE;
+} : {
+    engine: DE;
+    hostname: BackendSecret;
+    username: BackendSecret;
+    password: BackendSecret;
+    port: BackendSecret;
+    databaseName: BackendSecret;
+    vpcConfig?: Record<string, never>;
+};
+export type SchemaConfig<DE extends DatasourceEngine, DC extends DatasourceConfig<DE>> = {
+    database: DC;
+};
 export type ModelSchemaParamShape = {
     types: ModelSchemaContents;
     authorization: Authorization<any, any, any>[];
+    configuration: SchemaConfig<any, any>;
+};
+export type SQLModelSchemaParamShape = ModelSchemaParamShape & {
+    setSqlStatementFolderPath?: string;
 };
 export type InternalSchema = {
     data: {
@@ -27,6 +56,9 @@ export type ModelSchema<T extends ModelSchemaParamShape, UsedMethods extends 'au
     };
     transform: () => DerivedApiDefinition;
 };
+export type SqlModelSchema<T extends SQLModelSchemaParamShape, UsedMethods extends 'authorization' | 'setSqlStatementFolderPath' = never> = ModelSchema<T, Exclude<UsedMethods, 'setSqlStatementFolderPath'>> & Omit<{
+    setSqlStatementFolderPath: (path: string) => SqlModelSchema<T, UsedMethods | 'setSqlStatementFolderPath'>;
+}, UsedMethods>;
 /**
  * Amplify API Next Model Schema shape
  */
@@ -37,6 +69,15 @@ export type ModelSchemaType = ModelSchema<ModelSchemaParamShape>;
  * @returns true if the given value is a ModelSchema
  */
 export declare const isModelSchema: (schema: string | ModelSchemaType) => schema is ModelSchemaType;
+type SchemaReturnType<DE extends DatasourceEngine, Types extends ModelSchemaContents> = DE extends 'dynamodb' ? ModelSchema<{
+    types: Types;
+    authorization: [];
+    configuration: any;
+}> : SqlModelSchema<{
+    types: Types;
+    authorization: [];
+    configuration: any;
+}>;
 /**
  * The API and data model definition for Amplify Data. Pass in `{ <NAME>: a.model(...) }` to create a database table
  * and exposes CRUDL operations via an API.
@@ -44,7 +85,19 @@ export declare const isModelSchema: (schema: string | ModelSchemaType) => schema
  * @returns An API and data model definition to be deployed with Amplify (Gen 2) experience (`processSchema(...)`)
  * or with the Amplify Data CDK construct (`@aws-amplify/data-construct`)
  */
-export declare function schema<Types extends ModelSchemaContents>(types: Types): ModelSchema<{
+export declare const schema: <Types extends ModelSchemaContents>(types: Types) => ModelSchema<{
     types: Types;
     authorization: [];
-}>;
+    configuration: any;
+}, never>;
+/**
+ * Configure wraps schema definition with non-default config to allow usecases other than
+ * the default DynamoDB use-case.
+ *
+ * @param config The SchemaConfig augments the schema with content like the database type
+ * @returns
+ */
+export declare function configure<DE extends DatasourceEngine>(config: SchemaConfig<DE, DatasourceConfig<DE>>): {
+    schema: <Types extends ModelSchemaContents>(types: Types) => SchemaReturnType<DE, Types>;
+};
+export {};

package/lib-esm/src/ModelSchema.js

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = exports.isModelSchema = exports.__auth = void 0;
+exports.configure = exports.schema = exports.isModelSchema = void 0;
 const ModelType_1 = require("./ModelType");
-var ModelField_1 = require("./ModelField");
-Object.defineProperty(exports, "__auth", { enumerable: true, get: function () { return ModelField_1.__auth; } });
 const SchemaProcessor_1 = require("./SchemaProcessor");
 /**
  * Filter the schema types down to only include the ModelTypes as SchemaModelType
@@ -31,22 +29,41 @@ const isModelSchema = (schema) => {
     return typeof schema === 'object' && schema.data !== undefined;
 };
 exports.isModelSchema = isModelSchema;
-function _schema(types) {
-    const data = { types, authorization: [] };
-    const models = filterSchemaModelTypes(data.types);
-    const transform = () => {
-        const internalSchema = { data };
-        return (0, SchemaProcessor_1.processSchema)({ schema: internalSchema });
+function _sqlSchemaExtension(schema) {
+    return {
+        ...schema,
+        setSqlStatementFolderPath(path) {
+            this.data.setSqlStatementFolderPath = path;
+            const { setSqlStatementFolderPath: _, ...rest } = this;
+            return rest;
+        },
     };
-    const authorization = (rules) => {
-        data.authorization = rules;
-        return { data, transform, models };
+}
+function _baseSchema(types, config) {
+    const data = {
+        types,
+        authorization: [],
+        configuration: config,
     };
     return {
         data,
-        transform,
-        authorization,
-        models,
+        transform() {
+            const internalSchema = { data };
+            return (0, SchemaProcessor_1.processSchema)({ schema: internalSchema });
+        },
+        authorization(rules) {
+            this.data.authorization = rules;
+            const { authorization: _, ...rest } = this;
+            return rest;
+        },
+        models: filterSchemaModelTypes(data.types),
+    };
+}
+function bindConfigToSchema(config) {
+    return (types) => {
+        return (config.database.engine === 'dynamodb'
+            ? _baseSchema(types, config)
+            : _sqlSchemaExtension(_baseSchema(types, config)));
     };
 }
 /**
@@ -56,7 +73,17 @@ function _schema(types) {
  * @returns An API and data model definition to be deployed with Amplify (Gen 2) experience (`processSchema(...)`)
  * or with the Amplify Data CDK construct (`@aws-amplify/data-construct`)
  */
-function schema(types) {
-    return _schema(types);
+exports.schema = bindConfigToSchema({ database: { engine: 'dynamodb' } });
+/**
+ * Configure wraps schema definition with non-default config to allow usecases other than
+ * the default DynamoDB use-case.
+ *
+ * @param config The SchemaConfig augments the schema with content like the database type
+ * @returns
+ */
+function configure(config) {
+    return {
+        schema: bindConfigToSchema(config),
+    };
 }
-exports.schema = schema;
+exports.configure = configure;

package/lib-esm/src/ModelType.d.ts

@@ -1,4 +1,5 @@
-import type { Brand, SetTypeSubArg, SecondaryIndexIrShape } from '@aws-amplify/data-schema-types';
+import type { SetTypeSubArg, SecondaryIndexIrShape } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 import { ModelField, InternalField } from './ModelField';
 import type { ModelRelationalField, InternalRelationalField } from './ModelRelationalField';
 import { Authorization } from './Authorization';
@@ -7,7 +8,7 @@ import { EnumType, EnumTypeParamShape } from './EnumType';
 import { CustomType, CustomTypeParamShape } from './CustomType';
 import { ModelIndexType, InternalModelIndexType } from './ModelIndex';
 import { SecondaryIndexToIR } from './MappedTypes/MapSecondaryIndexes';
-declare const brand = "modelType";
+declare const brandName = "modelType";
 type ModelFields = Record<string, ModelField<any, any, any> | ModelRelationalField<any, string, any, any> | RefType<any, any, any> | EnumType<EnumTypeParamShape> | CustomType<CustomTypeParamShape>>;
 type InternalModelFields = Record<string, InternalField | InternalRelationalField>;
 type ModelData = {
@@ -44,7 +45,7 @@ export type ModelType<T extends ModelTypeParamShape, K extends keyof ModelType<T
     identifier<ID extends IdentifierType<T> = []>(identifier: ID): ModelType<SetTypeSubArg<T, 'identifier', ID>, K | 'identifier'>;
     secondaryIndexes<const Indexes extends readonly ModelIndexType<SecondaryIndexFields<ExtractType<T>>, SecondaryIndexFields<ExtractType<T>>, unknown, never, any>[] = readonly [], const IndexesIR extends readonly any[] = SecondaryIndexToIR<Indexes, ExtractType<T>>>(indexes: Indexes): ModelType<SetTypeSubArg<T, 'secondaryIndexes', IndexesIR>, K | 'secondaryIndexes'>;
     authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): ModelType<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
-}, K> & Brand<object, typeof brand>;
+}, K> & Brand<typeof brandName>;
 /**
  * External representation of Model Type that exposes the `addRelationships` modifier.
  * Used on the complete schema object.

package/lib-esm/src/ModelType.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.model = exports.isSchemaModelType = void 0;
-const brand = 'modelType';
+const util_1 = require("./util");
+const brandName = 'modelType';
 function _model(fields) {
     const data = {
         fields,
@@ -22,6 +23,7 @@ function _model(fields) {
             data.authorization = rules;
             return this;
         },
+        ...(0, util_1.brand)(brandName),
     };
     return {
         ...builder,

package/lib-esm/src/RefType.d.ts

@@ -1,4 +1,5 @@
-import { SetTypeSubArg, Brand } from '@aws-amplify/data-schema-types';
+import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
+import { Brand } from './util';
 import { Authorization } from './Authorization';
 import { __auth } from './ModelField';
 declare const brandName = "ref";
@@ -26,7 +27,7 @@ export type RefType<T extends RefTypeParamShape, K extends keyof RefType<T> = ne
     authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): RefType<T, K | 'authorization', AuthRuleType>;
 }, K> & {
     [__auth]?: Auth;
-} & Brand<object, typeof brandName>;
+} & Brand<typeof brandName>;
 /**
  * Internal representation of Ref that exposes the `data` property.
  * Used at buildtime.

package/lib-esm/src/SchemaProcessor.js

@@ -123,8 +123,8 @@ function refFieldToGql(fieldDef) {
     // }
     return field;
 }
-function customOperationToGql(typeName, typeDef) {
-    const { arguments: fieldArgs, returnType, authorization, functionRef, } = typeDef.data;
+function customOperationToGql(typeName, typeDef, authorization) {
+    const { arguments: fieldArgs, returnType, functionRef } = typeDef.data;
     let callSignature = typeName;
     const implicitModels = [];
     const { authString } = calculateAuth(authorization);
@@ -143,7 +143,7 @@ function customOperationToGql(typeName, typeDef) {
         throw new Error(`Unrecognized return type on ${typeName}`);
     }
     if (Object.keys(fieldArgs).length > 0) {
-        const { gqlFields, models } = processFields(fieldArgs, {});
+        const { gqlFields, models } = processFields(typeName, fieldArgs, {});
         callSignature += `(${gqlFields.join(', ')})`;
         implicitModels.push(...models);
     }
@@ -434,7 +434,7 @@ function processFieldLevelAuthRules(fields, authFields) {
     }
     return fieldLevelAuthRules;
 }
-function processFields(fields, fieldLevelAuthRules, identifier, partitionKey, secondaryIndexes = {}) {
+function processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey, secondaryIndexes = {}) {
     const gqlFields = [];
     const models = [];
     for (const [fieldName, fieldDef] of Object.entries(fields)) {
@@ -452,12 +452,16 @@ function processFields(fields, fieldLevelAuthRules, identifier, partitionKey, se
                 gqlFields.push(`${fieldName}: ${refFieldToGql(fieldDef.data)}${fieldAuth}`);
             }
             else if (isEnumType(fieldDef)) {
-                const enumName = capitalize(fieldName);
+                // The inline enum type name should be `<TypeName><FieldName>` to avoid
+                // enum type name conflicts
+                const enumName = `${capitalize(typeName)}${capitalize(fieldName)}`;
                 models.push([enumName, fieldDef]);
                 gqlFields.push(`${fieldName}: ${enumName}`);
             }
             else if (isCustomType(fieldDef)) {
-                const customTypeName = capitalize(fieldName);
+                // The inline CustomType name should be `<TypeName><FieldName>` to avoid
+                // CustomType name conflicts
+                const customTypeName = `${capitalize(typeName)}${capitalize(fieldName)}`;
                 models.push([customTypeName, fieldDef]);
                 gqlFields.push(`${fieldName}: ${customTypeName}`);
             }
@@ -520,8 +524,14 @@ const schemaPreprocessor = (schema) => {
     const fkFields = allImpliedFKs(schema);
     const topLevelTypes = Object.entries(schema.data.types);
     for (const [typeName, typeDef] of topLevelTypes) {
+        const mostRelevantAuthRules = typeDef.data?.authorization?.length > 0
+            ? typeDef.data.authorization
+            : schema.data.authorization;
         if (!isInternalModel(typeDef)) {
             if (isEnumType(typeDef)) {
+                if (typeDef.values.some((value) => /\s/.test(value))) {
+                    throw new Error(`Values of the enum type ${typeName} should not contain any whitespace.`);
+                }
                 const enumType = `enum ${typeName} {\n  ${typeDef.values.join('\n  ')}\n}`;
                 gqlModels.push(enumType);
             }
@@ -530,7 +540,7 @@ const schemaPreprocessor = (schema) => {
                 const authString = '';
                 const authFields = {};
                 const fieldLevelAuthRules = processFieldLevelAuthRules(fields, authFields);
-                const { gqlFields, models } = processFields(fields, fieldLevelAuthRules);
+                const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules);
                 topLevelTypes.push(...models);
                 const joined = gqlFields.join('\n  ');
                 const model = `type ${typeName} ${authString}\n{\n  ${joined}\n}`;
@@ -538,7 +548,15 @@ const schemaPreprocessor = (schema) => {
             }
             else if (isCustomOperation(typeDef)) {
                 const { typeName: opType } = typeDef.data;
-                const { gqlField, models } = customOperationToGql(typeName, typeDef);
+                if ((mostRelevantAuthRules.length > 0 && !typeDef.data.functionRef) ||
+                    (typeDef.data.functionRef && mostRelevantAuthRules.length < 1)) {
+                    // Deploying a custom operation with auth and no handler reference OR
+                    // with a handler reference but not auth
+                    // causes the CFN stack to reach an unrecoverable state. Ideally, this should be fixed
+                    // in the CDK construct, but we're catching it early here as a stopgap
+                    throw new Error(`Custom operation ${typeName} requires both an authorization rule and a handler reference`);
+                }
+                const { gqlField, models } = customOperationToGql(typeName, typeDef, mostRelevantAuthRules);
                 topLevelTypes.push(...models);
                 switch (opType) {
                     case 'Query':
@@ -560,15 +578,12 @@ const schemaPreprocessor = (schema) => {
             const identifier = typeDef.data.identifier;
             const [partitionKey] = identifier;
             const transformedSecondaryIndexes = transformedSecondaryIndexesForModel(typeDef.data.secondaryIndexes);
-            const mostRelevantAuthRules = typeDef.data.authorization.length > 0
-                ? typeDef.data.authorization
-                : schema.data.authorization;
             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);
-            const { gqlFields, models } = processFields({
+            const { gqlFields, models } = processFields(typeName, {
                 // ID fields are not merged outside `mergeFieldObjects` to skip
                 // validation, because the `identifer()` method doesn't specify or
                 // care what the underlying field type is. We should always just defer

package/lib-esm/src/index.d.ts

@@ -8,4 +8,5 @@ import { allow } from './Authorization';
 import { customType } from './CustomType';
 import { enumType } from './EnumType';
 import { query, mutation, subscription } from './CustomOperation';
-export { schema, model, modelIndex as index, ref, customType, enumType as enum, query, mutation, subscription, hasOne, hasMany, belongsTo, manyToMany, allow, id, string, integer, float, boolean, date, time, datetime, timestamp, email, json, phone, url, ipAddress, };
+import { handler } from './Handler';
+export { schema, model, modelIndex as index, ref, customType, enumType as enum, query, mutation, subscription, hasOne, hasMany, belongsTo, manyToMany, allow, id, string, integer, float, boolean, date, time, datetime, timestamp, email, json, phone, url, ipAddress, handler, };