@aws-amplify/data-schema 0.14.14 → 0.16.0

package/dist/esm/ModelIndex.mjs

@@ -0,0 +1,33 @@
+import { brand } from './util/Brand.mjs';
+
+const brandName = 'modelIndexType';
+function _modelIndex(partitionKeyFieldName) {
+    const data = {
+        partitionKey: partitionKeyFieldName,
+        sortKeys: [],
+        indexName: '',
+        queryField: '',
+    };
+    const builder = {
+        sortKeys(sortKeys) {
+            data.sortKeys = sortKeys;
+            return this;
+        },
+        name(name) {
+            data.indexName = name;
+            return this;
+        },
+        queryField(field) {
+            data.queryField = field;
+            return this;
+        },
+        ...brand(brandName),
+    };
+    return { ...builder, data };
+}
+function modelIndex(partitionKeyFieldName) {
+    return _modelIndex(partitionKeyFieldName);
+}
+
+export { modelIndex };
+//# sourceMappingURL=ModelIndex.mjs.map

package/dist/esm/ModelIndex.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelIndex.mjs","sources":["../../src/ModelIndex.ts"],"sourcesContent":["import { brand } from './util';\nconst brandName = 'modelIndexType';\nfunction _modelIndex(partitionKeyFieldName) {\n    const data = {\n        partitionKey: partitionKeyFieldName,\n        sortKeys: [],\n        indexName: '',\n        queryField: '',\n    };\n    const builder = {\n        sortKeys(sortKeys) {\n            data.sortKeys = sortKeys;\n            return this;\n        },\n        name(name) {\n            data.indexName = name;\n            return this;\n        },\n        queryField(field) {\n            data.queryField = field;\n            return this;\n        },\n        ...brand(brandName),\n    };\n    return { ...builder, data };\n}\nexport function modelIndex(partitionKeyFieldName) {\n    return _modelIndex(partitionKeyFieldName);\n}\n"],"names":[],"mappings":";;AACA,MAAM,SAAS,GAAG,gBAAgB,CAAC;AACnC,SAAS,WAAW,CAAC,qBAAqB,EAAE;AAC5C,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,YAAY,EAAE,qBAAqB;AAC3C,QAAQ,QAAQ,EAAE,EAAE;AACpB,QAAQ,SAAS,EAAE,EAAE;AACrB,QAAQ,UAAU,EAAE,EAAE;AACtB,KAAK,CAAC;AACN,IAAI,MAAM,OAAO,GAAG;AACpB,QAAQ,QAAQ,CAAC,QAAQ,EAAE;AAC3B,YAAY,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;AACrC,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,IAAI,CAAC,IAAI,EAAE;AACnB,YAAY,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;AAClC,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,UAAU,CAAC,KAAK,EAAE;AAC1B,YAAY,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;AACpC,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC;AAC3B,KAAK,CAAC;AACN,IAAI,OAAO,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,CAAC;AAChC,CAAC;AACM,SAAS,UAAU,CAAC,qBAAqB,EAAE;AAClD,IAAI,OAAO,WAAW,CAAC,qBAAqB,CAAC,CAAC;AAC9C;;;;"}

package/{lib-esm/src → dist/esm}/ModelRelationalField.d.ts

@@ -1,6 +1,6 @@
 import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import { Brand } from './util';
-import { Authorization } from './Authorization';
+import { AllowModifier, Authorization } from './Authorization';
 /**
  * Used to "attach" auth types to ModelField without exposing them on the builder.
  */
@@ -9,8 +9,7 @@ declare const brandName = "modelRelationalField";
 export declare enum ModelRelationshipTypes {
     hasOne = "hasOne",
     hasMany = "hasMany",
-    belongsTo = "belongsTo",
-    manyToMany = "manyToMany"
+    belongsTo = "belongsTo"
 }
 type RelationshipTypes = `${ModelRelationshipTypes}`;
 type ModelRelationalFieldData = {
@@ -20,8 +19,7 @@ type ModelRelationalFieldData = {
     array: boolean;
     valueRequired: boolean;
     arrayRequired: boolean;
-    relationName?: string;
-    references?: string[];
+    references: string[];
     authorization: Authorization<any, any, any>[];
 };
 export type ModelRelationalFieldParamShape = {
@@ -30,19 +28,14 @@ export type ModelRelationalFieldParamShape = {
     relatedModel: string;
     array: boolean;
     valueRequired: boolean;
-    references?: string[];
+    references: string[];
     arrayRequired: boolean;
-    relationName?: string;
 };
 type ModelRelationalFieldFunctions<T extends ModelRelationalFieldParamShape, RM extends string | symbol, K extends keyof ModelRelationalField<T, RM> = never> = {
     /**
      * When set, it requires the value of the relationship type to be required.
      */
     valueRequired(): ModelRelationalField<SetTypeSubArg<T, 'valueRequired', true>, K | 'valueRequired'>;
-    /**
-     * Reference sets the foreign key on which to establish the relationship
-     */
-    references(references: string[]): ModelRelationalField<SetTypeSubArg<T, 'references', string[]>, K | 'references'>;
     /**
      * When set, it requires the relationship to always return a value
      */
@@ -57,7 +50,7 @@ type ModelRelationalFieldFunctions<T extends ModelRelationalFieldParamShape, RM
      * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
      * multiple authorization rules for this field.
      */
-    authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): ModelRelationalField<T, K | 'authorization', K, AuthRuleType>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRuleType | AuthRuleType[]): ModelRelationalField<T, K | 'authorization', K, AuthRuleType>;
 };
 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;
@@ -69,15 +62,14 @@ export type ModelRelationalField<T extends ModelRelationalFieldParamShape, RM ex
 export type InternalRelationalField = ModelRelationalField<ModelRelationalFieldParamShape, string, never> & {
     data: ModelRelationalFieldData;
 };
-export type RelationTypeFunctionOmitMapping<Type extends ModelRelationshipTypes> = Type extends ModelRelationshipTypes.belongsTo ? 'required' | 'arrayRequired' | 'valueRequired' : Type extends ModelRelationshipTypes.hasMany ? 'required' : Type extends ModelRelationshipTypes.hasOne ? 'arrayRequired' | 'valueRequired' : Type extends ModelRelationshipTypes.manyToMany ? 'required' | 'references' : never;
-export type ModelRelationalTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean, RelationName extends string | undefined = undefined> = {
+export type RelationTypeFunctionOmitMapping<Type extends ModelRelationshipTypes> = Type extends ModelRelationshipTypes.belongsTo ? 'required' | 'arrayRequired' | 'valueRequired' : Type extends ModelRelationshipTypes.hasMany ? 'required' : Type extends ModelRelationshipTypes.hasOne ? 'arrayRequired' | 'valueRequired' : never;
+export type ModelRelationalTypeArgFactory<RM extends string, RT extends RelationshipTypes, IsArray extends boolean> = {
     type: 'model';
     relatedModel: RM;
     relationshipType: RT;
     array: IsArray;
     valueRequired: false;
     arrayRequired: false;
-    relationName: RelationName;
     references: string[];
 };
 /**
@@ -87,13 +79,13 @@ export type ModelRelationalTypeArgFactory<RM extends string, RT extends Relation
  * @param relatedModel the name of the related model
  * @returns a one-to-one relationship definition
  */
-export declare function hasOne<RM extends string>(relatedModel: RM): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false, undefined>, RM, "valueRequired" | "arrayRequired", undefined>;
+export declare function hasOne<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasOne, false>, RM, "valueRequired" | "arrayRequired", undefined>;
 /**
  * Create a one-directional one-to-many relationship between two models using the `hasMany()` method.
  * @param relatedModel the name of the related model
  * @returns a one-to-many relationship definition
  */
-export declare function hasMany<RM extends string>(relatedModel: RM): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true, undefined>, RM, "required", undefined>;
+export declare function hasMany<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.hasMany, true>, RM, "required", undefined>;
 /**
  * Make a `hasOne()` or `hasMany()` relationship bi-directional using the `belongsTo()` method.
  * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from
@@ -101,19 +93,5 @@ export declare function hasMany<RM extends string>(relatedModel: RM): ModelRelat
  * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model
  * @returns a belong-to relationship definition
  */
-export declare function belongsTo<RM extends string>(relatedModel: RM): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false, undefined>, RM, "required" | "valueRequired" | "arrayRequired", undefined>;
-/**
- * Create a many-to-many relationship between two models with the manyToMany() method.
- * Provide a common relationName on both models to join them into a many-to-many relationship.
- * Under the hood a many-to-many relationship is modeled with a "join table" with corresponding
- * `hasMany()` relationships between the two related models. You must set the same `manyToMany()`
- * field on both models of the relationship.
- * @param relatedModel name of the related model
- * @param opts pass in the `relationName` that will serve as the join table name for this many-to-many relationship
- * @returns a many-to-many relationship definition
- */
-export declare function manyToMany<RM extends string, RN extends string>(relatedModel: RM, opts: {
-    relationName: RN;
-}): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.manyToMany, true, RN>, RM, "required" | "references", undefined>;
+export declare function belongsTo<RM extends string>(relatedModel: RM, references: string | string[]): ModelRelationalField<ModelRelationalTypeArgFactory<RM, ModelRelationshipTypes.belongsTo, false>, RM, "valueRequired" | "arrayRequired" | "required", undefined>;
 export {};
-//# sourceMappingURL=ModelRelationalField.d.ts.map

package/dist/esm/ModelRelationalField.mjs

@@ -0,0 +1,88 @@
+import { allow } from './Authorization.mjs';
+
+/**
+ * Used to "attach" auth types to ModelField without exposing them on the builder.
+ */
+const __auth = Symbol('__auth');
+var ModelRelationshipTypes;
+(function (ModelRelationshipTypes) {
+    ModelRelationshipTypes["hasOne"] = "hasOne";
+    ModelRelationshipTypes["hasMany"] = "hasMany";
+    ModelRelationshipTypes["belongsTo"] = "belongsTo";
+})(ModelRelationshipTypes || (ModelRelationshipTypes = {}));
+const relationModifierMap = {
+    belongsTo: ['authorization'],
+    hasMany: ['arrayRequired', 'valueRequired', 'authorization'],
+    hasOne: ['required', 'authorization'],
+};
+function _modelRelationalField(type, relatedModel, references) {
+    const data = {
+        relatedModel,
+        type,
+        fieldType: 'model',
+        array: false,
+        valueRequired: false,
+        arrayRequired: false,
+        references,
+        authorization: [],
+    };
+    data.array = type === 'hasMany';
+    const relationshipBuilderFunctions = {
+        required() {
+            data.arrayRequired = true;
+            return this;
+        },
+        arrayRequired() {
+            data.arrayRequired = true;
+            return this;
+        },
+        valueRequired() {
+            data.valueRequired = true;
+            return this;
+        },
+        authorization(callback) {
+            const rules = callback(allow);
+            data.authorization = Array.isArray(rules) ? rules : [rules];
+            return this;
+        },
+    };
+    const builder = Object.fromEntries(relationModifierMap[type].map((key) => [
+        key,
+        relationshipBuilderFunctions[key],
+    ]));
+    return {
+        ...builder,
+        data,
+    };
+}
+/**
+ * Create a one-directional one-to-one relationship between two models using the `hasOne("MODEL_NAME")` method.
+ * A hasOne relationship always uses a reference to the related model's identifier. Typically this is the `id` field
+ * unless overwritten with the `identifier()` method.
+ * @param relatedModel the name of the related model
+ * @returns a one-to-one relationship definition
+ */
+function hasOne(relatedModel, references) {
+    return _modelRelationalField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);
+}
+/**
+ * Create a one-directional one-to-many relationship between two models using the `hasMany()` method.
+ * @param relatedModel the name of the related model
+ * @returns a one-to-many relationship definition
+ */
+function hasMany(relatedModel, references) {
+    return _modelRelationalField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);
+}
+/**
+ * Make a `hasOne()` or `hasMany()` relationship bi-directional using the `belongsTo()` method.
+ * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from
+ * parent to the related model.
+ * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model
+ * @returns a belong-to relationship definition
+ */
+function belongsTo(relatedModel, references) {
+    return _modelRelationalField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);
+}
+
+export { ModelRelationshipTypes, __auth, belongsTo, hasMany, hasOne };
+//# sourceMappingURL=ModelRelationalField.mjs.map

package/dist/esm/ModelRelationalField.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelRelationalField.mjs","sources":["../../src/ModelRelationalField.ts"],"sourcesContent":["import { allow } from './Authorization';\n/**\n * Used to \"attach\" auth types to ModelField without exposing them on the builder.\n */\nexport const __auth = Symbol('__auth');\nconst brandName = 'modelRelationalField';\nexport var ModelRelationshipTypes;\n(function (ModelRelationshipTypes) {\n    ModelRelationshipTypes[\"hasOne\"] = \"hasOne\";\n    ModelRelationshipTypes[\"hasMany\"] = \"hasMany\";\n    ModelRelationshipTypes[\"belongsTo\"] = \"belongsTo\";\n})(ModelRelationshipTypes || (ModelRelationshipTypes = {}));\nconst relationalModifiers = [\n    'required',\n    'arrayRequired',\n    'valueRequired',\n    'authorization',\n];\nconst relationModifierMap = {\n    belongsTo: ['authorization'],\n    hasMany: ['arrayRequired', 'valueRequired', 'authorization'],\n    hasOne: ['required', 'authorization'],\n};\nfunction _modelRelationalField(type, relatedModel, references) {\n    const data = {\n        relatedModel,\n        type,\n        fieldType: 'model',\n        array: false,\n        valueRequired: false,\n        arrayRequired: false,\n        references,\n        authorization: [],\n    };\n    data.array = type === 'hasMany';\n    const relationshipBuilderFunctions = {\n        required() {\n            data.arrayRequired = true;\n            return this;\n        },\n        arrayRequired() {\n            data.arrayRequired = true;\n            return this;\n        },\n        valueRequired() {\n            data.valueRequired = true;\n            return this;\n        },\n        authorization(callback) {\n            const rules = callback(allow);\n            data.authorization = Array.isArray(rules) ? rules : [rules];\n            return this;\n        },\n    };\n    const builder = Object.fromEntries(relationModifierMap[type].map((key) => [\n        key,\n        relationshipBuilderFunctions[key],\n    ]));\n    return {\n        ...builder,\n        data,\n    };\n}\n/**\n * Create a one-directional one-to-one relationship between two models using the `hasOne(\"MODEL_NAME\")` method.\n * A hasOne relationship always uses a reference to the related model's identifier. Typically this is the `id` field\n * unless overwritten with the `identifier()` method.\n * @param relatedModel the name of the related model\n * @returns a one-to-one relationship definition\n */\nexport function hasOne(relatedModel, references) {\n    return _modelRelationalField(ModelRelationshipTypes.hasOne, relatedModel, Array.isArray(references) ? references : [references]);\n}\n/**\n * Create a one-directional one-to-many relationship between two models using the `hasMany()` method.\n * @param relatedModel the name of the related model\n * @returns a one-to-many relationship definition\n */\nexport function hasMany(relatedModel, references) {\n    return _modelRelationalField(ModelRelationshipTypes.hasMany, relatedModel, Array.isArray(references) ? references : [references]);\n}\n/**\n * Make a `hasOne()` or `hasMany()` relationship bi-directional using the `belongsTo()` method.\n * The belongsTo() method requires that a hasOne() or hasMany() relationship already exists from\n * parent to the related model.\n * @param relatedModel name of the related `.hasOne()` or `.hasMany()` model\n * @returns a belong-to relationship definition\n */\nexport function belongsTo(relatedModel, references) {\n    return _modelRelationalField(ModelRelationshipTypes.belongsTo, relatedModel, Array.isArray(references) ? references : [references]);\n}\n"],"names":[],"mappings":"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"}

package/{lib-esm/src → dist/esm}/ModelSchema.d.ts

@@ -3,7 +3,7 @@ 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, MutationCustomOperation, QueryCustomOperation, SubscriptionCustomOperation } from './CustomOperation';
-import { SchemaAuthorization } from './Authorization';
+import { AllowModifier, SchemaAuthorization } from './Authorization';
 import { Brand } from './util';
 import { ModelRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
 export declare const rdsSchemaBrandName = "RDSSchema";
@@ -36,14 +36,14 @@ export type BaseSchema<T extends ModelSchemaParamShape, IsRDS extends boolean =
 };
 export type GenericModelSchema<T extends ModelSchemaParamShape> = BaseSchema<T> & Brand<typeof rdsSchemaBrandName | typeof ddbSchemaBrandName>;
 export type ModelSchema<T extends ModelSchemaParamShape, UsedMethods extends 'authorization' | 'addRelationships' = never> = Omit<{
-    authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(auth: AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
+    authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRules | AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
 }, UsedMethods> & BaseSchema<T> & DDBSchemaBrand;
 type RDSModelSchemaFunctions = 'addQueries' | 'addMutations' | 'addSubscriptions' | 'authorization' | 'relationships' | 'setAuthorization' | 'renameModelFields' | 'renameModels';
 export type RDSModelSchema<T extends RDSModelSchemaParamShape, UsedMethods extends RDSModelSchemaFunctions = never, RelationshipTemplate extends Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>> = Record<string, ModelRelationalField<ModelRelationalFieldParamShape, string, any, any>>> = Omit<{
     addQueries: <Queries extends Record<string, QueryCustomOperation>>(types: Queries) => RDSModelSchema<SetTypeSubArg<T, 'types', T['types'] & Queries>, UsedMethods | 'addQueries'>;
     addMutations: <Mutations extends Record<string, MutationCustomOperation>>(types: Mutations) => RDSModelSchema<SetTypeSubArg<T, 'types', T['types'] & Mutations>, UsedMethods | 'addMutations'>;
     addSubscriptions: <Subscriptions extends Record<string, SubscriptionCustomOperation>>(types: Subscriptions) => RDSModelSchema<SetTypeSubArg<T, 'types', T['types'] & Subscriptions>, UsedMethods | 'addSubscriptions'>;
-    authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(auth: AuthRules[]) => RDSModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
+    authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRules | AuthRules[]) => RDSModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
     setAuthorization: (callback: (models: BaseSchema<T, true>['models'], schema: RDSModelSchema<T, UsedMethods | 'setAuthorization'>) => void) => RDSModelSchema<T>;
     relationships: <Relationships extends ReadonlyArray<Partial<Record<keyof T['types'], RelationshipTemplate>>>>(callback: (models: BaseSchema<T, true>['models']) => Relationships) => RDSModelSchema<UnionToIntersection<Relationships[number]> extends infer RelationshipsDefs ? RelationshipsDefs extends Record<string, RelationshipTemplate> ? SetTypeSubArg<T, 'types', {
         [ModelName in keyof T['types']]: ModelName extends keyof RelationshipsDefs ? AddRelationshipFieldsToModelTypeFields<T['types'][ModelName], RelationshipsDefs[ModelName]> : T['types'][ModelName];
@@ -104,4 +104,3 @@ export type CustomPathData = {
     entry: string;
 };
 export {};
-//# sourceMappingURL=ModelSchema.d.ts.map

package/dist/esm/ModelSchema.mjs

@@ -0,0 +1,163 @@
+import { isSchemaModelType } from './ModelType.mjs';
+import { processSchema } from './SchemaProcessor.mjs';
+import { allow } from './Authorization.mjs';
+import { brand } from './util/Brand.mjs';
+
+const rdsSchemaBrandName = 'RDSSchema';
+const rdsSchemaBrand = brand(rdsSchemaBrandName);
+const ddbSchemaBrandName = 'DDBSchema';
+const ddbSchemaBrand = brand(ddbSchemaBrandName);
+/**
+ * Filter the schema types down to only include the ModelTypes as SchemaModelType
+ *
+ * @param schemaContents The object containing all SchemaContent for this schema
+ * @returns Only the schemaContents that are ModelTypes, coerced to the SchemaModelType surface
+ */
+const filterSchemaModelTypes = (schemaContents) => {
+    const modelTypes = {};
+    if (schemaContents) {
+        Object.entries(schemaContents).forEach(([key, content]) => {
+            if (isSchemaModelType(content)) {
+                modelTypes[key] = content;
+            }
+        });
+    }
+    return modelTypes;
+};
+/**
+ * Model Schema type guard
+ * @param schema - api-next ModelSchema or string
+ * @returns true if the given value is a ModelSchema
+ */
+const isModelSchema = (schema) => {
+    return typeof schema === 'object' && schema.data !== undefined;
+};
+function _rdsSchema(types, config) {
+    const data = {
+        types,
+        authorization: [],
+        configuration: config,
+    };
+    const models = filterSchemaModelTypes(data.types);
+    return {
+        data,
+        models,
+        transform() {
+            const internalSchema = { data };
+            return processSchema({ schema: internalSchema });
+        },
+        authorization(callback) {
+            const rules = callback(allow);
+            this.data.authorization = Array.isArray(rules) ? rules : [rules];
+            const { authorization: _, ...rest } = this;
+            return rest;
+        },
+        addQueries(types) {
+            this.data.types = { ...this.data.types, ...types };
+            const { addQueries: _, ...rest } = this;
+            return rest;
+        },
+        addMutations(types) {
+            this.data.types = { ...this.data.types, ...types };
+            const { addMutations: _, ...rest } = this;
+            return rest;
+        },
+        addSubscriptions(types) {
+            this.data.types = { ...this.data.types, ...types };
+            const { addSubscriptions: _, ...rest } = this;
+            return rest;
+        },
+        setAuthorization(callback) {
+            callback(models, this);
+            const { setAuthorization: _, ...rest } = this;
+            return rest;
+        },
+        relationships(callback) {
+            const { relationships: _, ...rest } = this;
+            // The relationships are added via `models.<Model>.addRelationships`
+            // modifiers that's being called within the callback. They are modifying
+            // by references on each model, so there is not anything else to be done
+            // here.
+            callback(models);
+            return rest;
+        },
+        renameModels(callback) {
+            const { renameModels: _, ...rest } = this;
+            // returns an array of tuples [curName, newName]
+            const changeLog = callback();
+            changeLog.forEach(([curName, newName]) => {
+                const currentType = data.types[curName];
+                if (currentType === undefined) {
+                    throw new Error(`Invalid renameModels call. ${curName} is not defined in the schema`);
+                }
+                if (typeof newName !== 'string' || newName.length < 1) {
+                    throw new Error(`Invalid renameModels call. New name must be a non-empty string. Received: "${newName}"`);
+                }
+                models[newName] = currentType;
+                data.types[newName] = currentType;
+                delete models[curName];
+                delete data.types[curName];
+            });
+            return rest;
+        },
+        ...rdsSchemaBrand,
+    };
+}
+function _ddbSchema(types, config) {
+    const data = {
+        types,
+        authorization: [],
+        configuration: config,
+    };
+    return {
+        data,
+        transform() {
+            const internalSchema = { data };
+            return processSchema({ schema: internalSchema });
+        },
+        authorization(callback) {
+            const rules = callback(allow);
+            this.data.authorization = Array.isArray(rules) ? rules : [rules];
+            const { authorization: _, ...rest } = this;
+            return rest;
+        },
+        models: filterSchemaModelTypes(data.types),
+        ...ddbSchemaBrand,
+    };
+}
+function bindConfigToSchema(config) {
+    return (types) => {
+        return (config.database.engine === 'dynamodb'
+            ? _ddbSchema(types, config)
+            : _rdsSchema(types, config));
+    };
+}
+/**
+ * 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.
+ * @param types The API and data model definition
+ * @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`)
+ */
+const 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),
+    };
+}
+function isCustomPathData(obj) {
+    return ('stack' in obj &&
+        (typeof obj.stack === 'undefined' || typeof obj.stack === 'string') &&
+        'entry' in obj &&
+        typeof obj.entry === 'string');
+}
+
+export { configure, ddbSchemaBrandName, isCustomPathData, isModelSchema, rdsSchemaBrand, rdsSchemaBrandName, schema };
+//# sourceMappingURL=ModelSchema.mjs.map

package/dist/esm/ModelSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelSchema.mjs","sources":["../../src/ModelSchema.ts"],"sourcesContent":["import { isSchemaModelType, } from './ModelType';\nimport { processSchema } from './SchemaProcessor';\nimport { allow } from './Authorization';\nimport { brand } from './util';\nexport const rdsSchemaBrandName = 'RDSSchema';\nexport const rdsSchemaBrand = brand(rdsSchemaBrandName);\nexport const ddbSchemaBrandName = 'DDBSchema';\nconst ddbSchemaBrand = brand(ddbSchemaBrandName);\n/**\n * Filter the schema types down to only include the ModelTypes as SchemaModelType\n *\n * @param schemaContents The object containing all SchemaContent for this schema\n * @returns Only the schemaContents that are ModelTypes, coerced to the SchemaModelType surface\n */\nconst filterSchemaModelTypes = (schemaContents) => {\n    const modelTypes = {};\n    if (schemaContents) {\n        Object.entries(schemaContents).forEach(([key, content]) => {\n            if (isSchemaModelType(content)) {\n                modelTypes[key] = content;\n            }\n        });\n    }\n    return modelTypes;\n};\n/**\n * Model Schema type guard\n * @param schema - api-next ModelSchema or string\n * @returns true if the given value is a ModelSchema\n */\nexport const isModelSchema = (schema) => {\n    return typeof schema === 'object' && schema.data !== undefined;\n};\nfunction _rdsSchema(types, config) {\n    const data = {\n        types,\n        authorization: [],\n        configuration: config,\n    };\n    const models = filterSchemaModelTypes(data.types);\n    return {\n        data,\n        models,\n        transform() {\n            const internalSchema = { data };\n            return processSchema({ schema: internalSchema });\n        },\n        authorization(callback) {\n            const rules = callback(allow);\n            this.data.authorization = Array.isArray(rules) ? rules : [rules];\n            const { authorization: _, ...rest } = this;\n            return rest;\n        },\n        addQueries(types) {\n            this.data.types = { ...this.data.types, ...types };\n            const { addQueries: _, ...rest } = this;\n            return rest;\n        },\n        addMutations(types) {\n            this.data.types = { ...this.data.types, ...types };\n            const { addMutations: _, ...rest } = this;\n            return rest;\n        },\n        addSubscriptions(types) {\n            this.data.types = { ...this.data.types, ...types };\n            const { addSubscriptions: _, ...rest } = this;\n            return rest;\n        },\n        setAuthorization(callback) {\n            callback(models, this);\n            const { setAuthorization: _, ...rest } = this;\n            return rest;\n        },\n        relationships(callback) {\n            const { relationships: _, ...rest } = this;\n            // The relationships are added via `models.<Model>.addRelationships`\n            // modifiers that's being called within the callback. They are modifying\n            // by references on each model, so there is not anything else to be done\n            // here.\n            callback(models);\n            return rest;\n        },\n        renameModels(callback) {\n            const { renameModels: _, ...rest } = this;\n            // returns an array of tuples [curName, newName]\n            const changeLog = callback();\n            changeLog.forEach(([curName, newName]) => {\n                const currentType = data.types[curName];\n                if (currentType === undefined) {\n                    throw new Error(`Invalid renameModels call. ${curName} is not defined in the schema`);\n                }\n                if (typeof newName !== 'string' || newName.length < 1) {\n                    throw new Error(`Invalid renameModels call. New name must be a non-empty string. Received: \"${newName}\"`);\n                }\n                models[newName] = currentType;\n                data.types[newName] = currentType;\n                delete models[curName];\n                delete data.types[curName];\n            });\n            return rest;\n        },\n        ...rdsSchemaBrand,\n    };\n}\nfunction _ddbSchema(types, config) {\n    const data = {\n        types,\n        authorization: [],\n        configuration: config,\n    };\n    return {\n        data,\n        transform() {\n            const internalSchema = { data };\n            return processSchema({ schema: internalSchema });\n        },\n        authorization(callback) {\n            const rules = callback(allow);\n            this.data.authorization = Array.isArray(rules) ? rules : [rules];\n            const { authorization: _, ...rest } = this;\n            return rest;\n        },\n        models: filterSchemaModelTypes(data.types),\n        ...ddbSchemaBrand,\n    };\n}\nfunction bindConfigToSchema(config) {\n    return (types) => {\n        return (config.database.engine === 'dynamodb'\n            ? _ddbSchema(types, config)\n            : _rdsSchema(types, config));\n    };\n}\n/**\n * The API and data model definition for Amplify Data. Pass in `{ <NAME>: a.model(...) }` to create a database table\n * and exposes CRUDL operations via an API.\n * @param types The API and data model definition\n * @returns An API and data model definition to be deployed with Amplify (Gen 2) experience (`processSchema(...)`)\n * or with the Amplify Data CDK construct (`@aws-amplify/data-construct`)\n */\nexport const schema = bindConfigToSchema({ database: { engine: 'dynamodb' } });\n/**\n * Configure wraps schema definition with non-default config to allow usecases other than\n * the default DynamoDB use-case.\n *\n * @param config The SchemaConfig augments the schema with content like the database type\n * @returns\n */\nexport function configure(config) {\n    return {\n        schema: bindConfigToSchema(config),\n    };\n}\nexport function isCustomPathData(obj) {\n    return ('stack' in obj &&\n        (typeof obj.stack === 'undefined' || typeof obj.stack === 'string') &&\n        'entry' in obj &&\n        typeof obj.entry === 'string');\n}\n"],"names":[],"mappings":"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"}

package/{lib-esm/src → dist/esm}/ModelType.d.ts

@@ -2,7 +2,7 @@ import type { SetTypeSubArg, SecondaryIndexIrShape } from '@aws-amplify/data-sch
 import { Brand } from './util';
 import { ModelField, InternalField } from './ModelField';
 import type { ModelRelationalField, InternalRelationalField, ModelRelationalFieldParamShape } from './ModelRelationalField';
-import { Authorization } from './Authorization';
+import { AllowModifier, Authorization } from './Authorization';
 import { RefType } from './RefType';
 import { EnumType, EnumTypeParamShape } from './EnumType';
 import { CustomType, CustomTypeParamShape } from './CustomType';
@@ -45,7 +45,7 @@ export type AddRelationshipFieldsToModelTypeFields<Model, RelationshipFields ext
 export type ModelType<T extends ModelTypeParamShape, K extends keyof ModelType<T> = never> = Omit<{
     identifier<ID extends IdentifierType<T> = []>(identifier: ID): ModelType<SetTypeSubArg<T, 'identifier', ID>, K | 'identifier'>;
     secondaryIndexes<const SecondaryIndexPKPool extends string = SecondaryIndexFields<ExtractType<T>>, const Indexes extends readonly ModelIndexType<string, string, unknown, readonly [], any>[] = readonly [], const IndexesIR extends readonly any[] = SecondaryIndexToIR<Indexes, ExtractType<T>>>(callback: (index: <PK extends SecondaryIndexPKPool>(pk: PK) => ModelIndexType<SecondaryIndexPKPool, PK, ReadonlyArray<Exclude<SecondaryIndexPKPool, PK>>>) => Indexes): ModelType<SetTypeSubArg<T, 'secondaryIndexes', IndexesIR>, K | 'secondaryIndexes'>;
-    authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): ModelType<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: Omit<AllowModifier, 'resource'>) => AuthRuleType | AuthRuleType[]): ModelType<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
 }, K> & Brand<typeof brandName>;
 /**
  * External representation of Model Type that exposes the `addRelationships` modifier.
@@ -82,4 +82,3 @@ export declare function model<T extends ModelFields>(fields: T): ModelType<{
     authorization: [];
 }>;
 export {};
-//# sourceMappingURL=ModelType.d.ts.map

package/dist/esm/ModelType.mjs

@@ -0,0 +1,66 @@
+import { brand } from './util/Brand.mjs';
+import { allow } from './Authorization.mjs';
+import { modelIndex } from './ModelIndex.mjs';
+
+const brandName = 'modelType';
+function _model(fields) {
+    const data = {
+        fields,
+        identifier: ['id'],
+        secondaryIndexes: [],
+        authorization: [],
+    };
+    const builder = {
+        identifier(identifier) {
+            data.identifier = identifier;
+            return this;
+        },
+        secondaryIndexes(callback) {
+            data.secondaryIndexes = callback(modelIndex);
+            return this;
+        },
+        authorization(callback) {
+            const { resource: _, ...rest } = allow;
+            const rules = callback(rest);
+            data.authorization = Array.isArray(rules) ? rules : [rules];
+            return this;
+        },
+        ...brand(brandName),
+    };
+    return {
+        ...builder,
+        data,
+        addRelationships(relationships) {
+            data.fields = { ...data.fields, ...relationships };
+        },
+        fields: data.fields,
+    };
+}
+/**
+ * Model Type type guard
+ * @param modelType - api-next ModelType
+ * @returns true if the given value is a ModelSchema
+ */
+const isSchemaModelType = (modelType) => {
+    const internalType = modelType;
+    return (typeof internalType === 'object' &&
+        internalType.data !== undefined &&
+        internalType.data.fields !== undefined &&
+        internalType.data.authorization !== undefined &&
+        internalType.data.identifier !== undefined &&
+        internalType.data.secondaryIndexes !== undefined &&
+        typeof internalType.addRelationships === 'function');
+};
+/**
+ * A data model that creates a matching Amazon DynamoDB table and provides create, read (list and get), update,
+ * delete, and subscription APIs.
+ *
+ * @param fields database table fields. Supports scalar types and relationship types.
+ * @returns a data model definition
+ */
+function model(fields) {
+    return _model(fields);
+}
+
+export { isSchemaModelType, model };
+//# sourceMappingURL=ModelType.mjs.map

package/dist/esm/ModelType.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ModelType.mjs","sources":["../../src/ModelType.ts"],"sourcesContent":["import { brand } from './util';\nimport { allow } from './Authorization';\nimport { modelIndex, } from './ModelIndex';\nconst brandName = 'modelType';\nfunction _model(fields) {\n    const data = {\n        fields,\n        identifier: ['id'],\n        secondaryIndexes: [],\n        authorization: [],\n    };\n    const builder = {\n        identifier(identifier) {\n            data.identifier = identifier;\n            return this;\n        },\n        secondaryIndexes(callback) {\n            data.secondaryIndexes = callback(modelIndex);\n            return this;\n        },\n        authorization(callback) {\n            const { resource: _, ...rest } = allow;\n            const rules = callback(rest);\n            data.authorization = Array.isArray(rules) ? rules : [rules];\n            return this;\n        },\n        ...brand(brandName),\n    };\n    return {\n        ...builder,\n        data,\n        addRelationships(relationships) {\n            data.fields = { ...data.fields, ...relationships };\n        },\n        fields: data.fields,\n    };\n}\n/**\n * Model Type type guard\n * @param modelType - api-next ModelType\n * @returns true if the given value is a ModelSchema\n */\nexport const isSchemaModelType = (modelType) => {\n    const internalType = modelType;\n    return (typeof internalType === 'object' &&\n        internalType.data !== undefined &&\n        internalType.data.fields !== undefined &&\n        internalType.data.authorization !== undefined &&\n        internalType.data.identifier !== undefined &&\n        internalType.data.secondaryIndexes !== undefined &&\n        typeof internalType.addRelationships === 'function');\n};\n/**\n * A data model that creates a matching Amazon DynamoDB table and provides create, read (list and get), update,\n * delete, and subscription APIs.\n *\n * @param fields database table fields. Supports scalar types and relationship types.\n * @returns a data model definition\n */\nexport function model(fields) {\n    return _model(fields);\n}\n"],"names":[],"mappings":";;;;AAGA,MAAM,SAAS,GAAG,WAAW,CAAC;AAC9B,SAAS,MAAM,CAAC,MAAM,EAAE;AACxB,IAAI,MAAM,IAAI,GAAG;AACjB,QAAQ,MAAM;AACd,QAAQ,UAAU,EAAE,CAAC,IAAI,CAAC;AAC1B,QAAQ,gBAAgB,EAAE,EAAE;AAC5B,QAAQ,aAAa,EAAE,EAAE;AACzB,KAAK,CAAC;AACN,IAAI,MAAM,OAAO,GAAG;AACpB,QAAQ,UAAU,CAAC,UAAU,EAAE;AAC/B,YAAY,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;AACzC,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,gBAAgB,CAAC,QAAQ,EAAE;AACnC,YAAY,IAAI,CAAC,gBAAgB,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAC;AACzD,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,aAAa,CAAC,QAAQ,EAAE;AAChC,YAAY,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,KAAK,CAAC;AACnD,YAAY,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC;AACzC,YAAY,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,GAAG,KAAK,GAAG,CAAC,KAAK,CAAC,CAAC;AACxE,YAAY,OAAO,IAAI,CAAC;AACxB,SAAS;AACT,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC;AAC3B,KAAK,CAAC;AACN,IAAI,OAAO;AACX,QAAQ,GAAG,OAAO;AAClB,QAAQ,IAAI;AACZ,QAAQ,gBAAgB,CAAC,aAAa,EAAE;AACxC,YAAY,IAAI,CAAC,MAAM,GAAG,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,aAAa,EAAE,CAAC;AAC/D,SAAS;AACT,QAAQ,MAAM,EAAE,IAAI,CAAC,MAAM;AAC3B,KAAK,CAAC;AACN,CAAC;AACD;AACA;AACA;AACA;AACA;AACY,MAAC,iBAAiB,GAAG,CAAC,SAAS,KAAK;AAChD,IAAI,MAAM,YAAY,GAAG,SAAS,CAAC;AACnC,IAAI,QAAQ,OAAO,YAAY,KAAK,QAAQ;AAC5C,QAAQ,YAAY,CAAC,IAAI,KAAK,SAAS;AACvC,QAAQ,YAAY,CAAC,IAAI,CAAC,MAAM,KAAK,SAAS;AAC9C,QAAQ,YAAY,CAAC,IAAI,CAAC,aAAa,KAAK,SAAS;AACrD,QAAQ,YAAY,CAAC,IAAI,CAAC,UAAU,KAAK,SAAS;AAClD,QAAQ,YAAY,CAAC,IAAI,CAAC,gBAAgB,KAAK,SAAS;AACxD,QAAQ,OAAO,YAAY,CAAC,gBAAgB,KAAK,UAAU,EAAE;AAC7D,EAAE;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACO,SAAS,KAAK,CAAC,MAAM,EAAE;AAC9B,IAAI,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC;AAC1B;;;;"}

package/{lib-esm/src → dist/esm}/RefType.d.ts

@@ -1,6 +1,6 @@
 import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
 import { Brand } from './util';
-import { Authorization } from './Authorization';
+import { AllowModifier, Authorization } from './Authorization';
 import { __auth } from './ModelField';
 declare const brandName = "ref";
 type RefTypeData = {
@@ -34,7 +34,7 @@ export type RefType<T extends RefTypeParamShape, K extends keyof RefType<T> = ne
      * Configures field-level authorization rules. Pass in an array of authorizations `(a.allow.____)` to mix and match
      * multiple authorization rules for this field.
      */
-    authorization<AuthRuleType extends Authorization<any, any, any>>(rules: AuthRuleType[]): RefType<T, K | 'authorization', AuthRuleType>;
+    authorization<AuthRuleType extends Authorization<any, any, any>>(callback: (allow: AllowModifier) => AuthRuleType | AuthRuleType[]): RefType<T, K | 'authorization', AuthRuleType>;
     mutations(operations: MutationOperations[]): RefType<T, K | 'mutations'>;
 }, K> & {
     [__auth]?: Auth;
@@ -56,4 +56,3 @@ type RefTypeArgFactory<Link extends string> = {
 };
 export declare function ref<Value extends string, T extends Value>(link: T): RefType<RefTypeArgFactory<T>, never, undefined>;
 export {};
-//# sourceMappingURL=RefType.d.ts.map

package/dist/esm/RefType.mjs

@@ -0,0 +1,48 @@
+import { allow } from './Authorization.mjs';
+import './ModelField.mjs';
+
+function brandedBuilder(builder) {
+    return builder;
+}
+function _ref(link) {
+    const data = {
+        type: 'ref',
+        link,
+        valueRequired: false,
+        array: false,
+        arrayRequired: false,
+        mutationOperations: [],
+        authorization: [],
+    };
+    const builder = brandedBuilder({
+        required() {
+            if (data.array) {
+                data.arrayRequired = true;
+            }
+            else {
+                data.valueRequired = true;
+            }
+            return this;
+        },
+        array() {
+            data.array = true;
+            return this;
+        },
+        authorization(callback) {
+            const rules = callback(allow);
+            data.authorization = Array.isArray(rules) ? rules : [rules];
+            return this;
+        },
+        mutations(operations) {
+            data.mutationOperations = operations;
+            return this;
+        },
+    });
+    return { ...builder, data };
+}
+function ref(link) {
+    return _ref(link);
+}
+
+export { ref };
+//# sourceMappingURL=RefType.mjs.map