@aws-amplify/data-schema 0.11.0

package/lib-esm/src/ModelRelationalField.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.manyToMany = exports.belongsTo = exports.hasMany = exports.hasOne = exports.ModelRelationshipTypes = exports.__auth = void 0;
+/**
+ * Used to "attach" auth types to ModelField without exposing them on the builder.
+ */
+exports.__auth = Symbol('__auth');
+var ModelRelationshipTypes;
+(function (ModelRelationshipTypes) {
+    ModelRelationshipTypes["hasOne"] = "hasOne";
+    ModelRelationshipTypes["hasMany"] = "hasMany";
+    ModelRelationshipTypes["belongsTo"] = "belongsTo";
+    ModelRelationshipTypes["manyToMany"] = "manyToMany";
+})(ModelRelationshipTypes || (exports.ModelRelationshipTypes = ModelRelationshipTypes = {}));
+const arrayTypeRelationships = ['hasMany', 'manyToMany'];
+const relationalModifiers = [
+    'required',
+    'arrayRequired',
+    'valueRequired',
+    'authorization',
+];
+const relationModifierMap = {
+    belongsTo: ['authorization'],
+    hasMany: ['arrayRequired', 'valueRequired', 'authorization'],
+    hasOne: ['required', 'authorization'],
+    manyToMany: ['arrayRequired', 'valueRequired', 'authorization'],
+};
+function _modelRelationalField(type, relatedModel, relationName) {
+    const data = {
+        relatedModel,
+        type,
+        fieldType: 'model',
+        array: false,
+        valueRequired: false,
+        arrayRequired: false,
+        relationName,
+        authorization: [],
+    };
+    if (arrayTypeRelationships.includes(type)) {
+        data.array = true;
+    }
+    const relationshipBuilderFunctions = {
+        required() {
+            data.arrayRequired = true;
+            return this;
+        },
+        arrayRequired() {
+            data.arrayRequired = true;
+            return this;
+        },
+        valueRequired() {
+            data.valueRequired = true;
+            return this;
+        },
+        authorization(rules) {
+            data.authorization = 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) {
+    return _modelRelationalField(ModelRelationshipTypes.hasOne, relatedModel);
+}
+exports.hasOne = hasOne;
+/**
+ * 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) {
+    return _modelRelationalField(ModelRelationshipTypes.hasMany, relatedModel);
+}
+exports.hasMany = hasMany;
+/**
+ * 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) {
+    return _modelRelationalField(ModelRelationshipTypes.belongsTo, relatedModel);
+}
+exports.belongsTo = belongsTo;
+/**
+ * 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
+ */
+function manyToMany(relatedModel, opts) {
+    return _modelRelationalField(ModelRelationshipTypes.manyToMany, relatedModel, opts.relationName);
+}
+exports.manyToMany = manyToMany;

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

@@ -0,0 +1,39 @@
+import type { DerivedApiDefinition } from '@aws-amplify/data-schema-types';
+import type { ModelType, ModelTypeParamShape, InternalModel } from './ModelType';
+import type { EnumType } from './EnumType';
+import type { CustomType } from './CustomType';
+export { __auth } from './ModelField';
+type ModelSchemaModels = Record<string, ModelType<ModelTypeParamShape, any>>;
+type InternalSchemaModels = Record<string, InternalModel | EnumType<any> | CustomType<any>>;
+export type ModelSchemaParamShape = {
+    types: ModelSchemaModels;
+};
+export type InternalSchema = {
+    data: {
+        types: InternalSchemaModels;
+    };
+};
+export type ModelSchema<T extends ModelSchemaParamShape> = {
+    data: T;
+    transform: () => DerivedApiDefinition;
+};
+/**
+ * Amplify API Next Model Schema shape
+ */
+export type ModelSchemaType = ModelSchema<ModelSchemaParamShape>;
+/**
+ * Model Schema type guard
+ * @param schema - api-next ModelSchema or string
+ * @returns true if the given value is a ModelSchema
+ */
+export declare const isModelSchema: (schema: string | ModelSchemaType) => schema is ModelSchemaType;
+/**
+ * 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`)
+ */
+export declare function schema<Types extends ModelSchemaModels>(types: Types): ModelSchema<{
+    types: Types;
+}>;

package/lib-esm/src/ModelSchema.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.isModelSchema = exports.__auth = void 0;
+var ModelField_1 = require("./ModelField");
+Object.defineProperty(exports, "__auth", { enumerable: true, get: function () { return ModelField_1.__auth; } });
+const SchemaProcessor_1 = require("./SchemaProcessor");
+/**
+ * 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;
+};
+exports.isModelSchema = isModelSchema;
+function _schema(types) {
+    const data = { types };
+    const transform = () => {
+        const internalSchema = { data };
+        return (0, SchemaProcessor_1.processSchema)({ schema: internalSchema });
+    };
+    return { data, transform };
+}
+/**
+ * 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`)
+ */
+function schema(types) {
+    return _schema(types);
+}
+exports.schema = schema;

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

@@ -0,0 +1,107 @@
+import type { SetTypeSubArg } from '@aws-amplify/data-schema-types';
+import { ModelField, InternalField } from './ModelField';
+import type { ModelRelationalField, InternalRelationalField } from './ModelRelationalField';
+import { Authorization } from './Authorization';
+import { RefType } from './RefType';
+type ModelFields = Record<string, ModelField<any, any> | ModelRelationalField<any, string, any> | RefType<any, any>>;
+type InternalModelFields = Record<string, InternalField | InternalRelationalField>;
+type ModelData = {
+    fields: ModelFields;
+    identifier: string[];
+    authorization: Authorization<any, any>[];
+};
+type InternalModelData = ModelData & {
+    fields: InternalModelFields;
+    identifier: string[];
+    authorization: Authorization<any, any>[];
+};
+export type ModelTypeParamShape = {
+    fields: ModelFields;
+    identifier: string[];
+    authorization: Authorization<any, any>[];
+};
+type ExtractType<T extends ModelTypeParamShape> = {
+    [FieldProp in keyof T['fields']]: T['fields'][FieldProp] extends ModelField<infer R, any> ? R : never;
+};
+type GetRequiredFields<T> = {
+    [FieldProp in keyof T as T[FieldProp] extends NonNullable<T[FieldProp]> ? FieldProp : never]: T[FieldProp];
+};
+type IdentifierMap<T extends ModelTypeParamShape> = GetRequiredFields<ExtractType<T>>;
+type IdentifierFields<T extends ModelTypeParamShape> = keyof IdentifierMap<T> & string;
+type IdentifierType<T extends ModelTypeParamShape, Fields extends string = IdentifierFields<T>> = Array<Fields>;
+/**
+ * For a given ModelTypeParamShape, produces a map of Authorization rules
+ * that would *conflict* with the given type.
+ *
+ * E.g.,
+ *
+ * ```
+ * const test = {
+ *  fields: {
+ *   title: fields.string(),
+ *   otherfield: fields.string().array(),
+ *   numfield: fields.integer(),
+ *  },
+ *  identifier: [],
+ *  authorization: [],
+ * };
+ *
+ * ConflictingAuthRulesMap<typeof test> === {
+ *  title: Authorization<"title", true>;
+ *  otherfield: Authorization<"otherfield", false>;
+ *  numfield: Authorization<"numfield", true> | Authorization<"numfield", false>;
+ * }
+ * ```
+ */
+type ConflictingAuthRulesMap<T extends ModelTypeParamShape> = {
+    [K in keyof ExtractType<T>]: K extends string ? string extends ExtractType<T>[K] ? Authorization<K, true> : string[] extends ExtractType<T>[K] ? Authorization<K, false> : Authorization<K, true> | Authorization<K, false> : never;
+};
+/**
+ * For a given ModelTypeParamShape, produces a union of Authorization rules
+ * that would *conflict* with the given type.
+ *
+ * E.g.,
+ *
+ * ```
+ * const test = {
+ *  fields: {
+ *   title: fields.string(),
+ *   otherfield: fields.string().array(),
+ *   numfield: fields.integer(),
+ *  },
+ *  identifier: [],
+ *  authorization: [],
+ * };
+ *
+ * ConflictingAuthRules<typeof test> ===
+ *  Authorization<"title", true>
+ *  | Authorization<"otherfield", false>
+ *  | Authorization<"numfield", true> | Authorization<"numfield", false>
+ * ;
+ * ```
+ */
+type ConflictingAuthRules<T extends ModelTypeParamShape> = ConflictingAuthRulesMap<T>[keyof ConflictingAuthRulesMap<T>];
+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'>;
+    authorization<AuthRuleType extends Authorization<any, any>>(rules: Exclude<AuthRuleType, ConflictingAuthRules<T>>[]): ModelType<SetTypeSubArg<T, 'authorization', AuthRuleType[]>, K | 'authorization'>;
+}, K>;
+/**
+ * Internal representation of Model Type that exposes the `data` property.
+ * Used at buildtime.
+ */
+export type InternalModel = ModelType<any> & {
+    data: InternalModelData;
+};
+/**
+ * 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
+ */
+export declare function model<T extends ModelFields>(fields: T): ModelType<{
+    fields: T;
+    identifier: Array<'id'>;
+    authorization: [];
+}>;
+export {};

package/lib-esm/src/ModelType.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.model = void 0;
+function _model(fields) {
+    const data = {
+        fields,
+        identifier: ['id'],
+        authorization: [],
+    };
+    const builder = {
+        identifier(identifier) {
+            data.identifier = identifier;
+            return this;
+        },
+        authorization(rules) {
+            data.authorization = rules;
+            return this;
+        },
+    };
+    return { ...builder, data };
+}
+/**
+ * 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);
+}
+exports.model = model;

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

@@ -0,0 +1,45 @@
+import { SetTypeSubArg } from '@aws-amplify/data-schema-types';
+import { Authorization } from './Authorization';
+import { __auth } from './ModelField';
+export declare const __ref: unique symbol;
+export type RefTypeParamShape = {
+    type: 'ref';
+    link: string;
+    required: boolean;
+    authorization: Authorization<any, any>[];
+};
+export type RefType<T extends RefTypeParamShape, K extends keyof RefType<T> = never, Auth = undefined> = Omit<{
+    /**
+     * Marks a field as required.
+     */
+    required(): RefType<SetTypeSubArg<T, 'required', true>, K | 'required'>;
+    /**
+     * 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>>(rules: AuthRuleType[]): RefType<T, K | 'authorization', AuthRuleType>;
+    [__ref]: typeof __ref;
+}, K> & {
+    [__auth]?: Auth;
+};
+type RefTypeData = {
+    type: 'ref';
+    link: string;
+    required: boolean;
+    authorization: Authorization<any, any>[];
+};
+/**
+ * Internal representation of Ref that exposes the `data` property.
+ * Used at buildtime.
+ */
+export type InternalRef = RefType<RefTypeParamShape> & {
+    data: RefTypeData;
+};
+type RefTypeArgFactory<Link extends string> = {
+    type: 'ref';
+    link: Link;
+    required: false;
+    authorization: [];
+};
+export declare function ref<Value extends string, T extends Value>(link: T): RefType<RefTypeArgFactory<T>, never, undefined>;
+export {};

package/lib-esm/src/RefType.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ref = exports.__ref = void 0;
+const ModelField_1 = require("./ModelField");
+exports.__ref = Symbol('__ref');
+function _ref(link) {
+    const data = {
+        type: 'ref',
+        link,
+        required: false,
+        authorization: [],
+    };
+    const builder = {
+        required() {
+            data.required = true;
+            return this;
+        },
+        authorization(rules) {
+            data.authorization = rules;
+            return this;
+        },
+        [exports.__ref]: exports.__ref,
+    };
+    return { ...builder, data };
+}
+function ref(link) {
+    return _ref(link);
+}
+exports.ref = ref;

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

@@ -0,0 +1,10 @@
+import type { InternalSchema } from './ModelSchema';
+import { DerivedApiDefinition } from './types';
+/**
+ * Returns API definition from ModelSchema or string schema
+ * @param arg - { schema }
+ * @returns DerivedApiDefinition that conforms to IAmplifyGraphqlDefinition
+ */
+export declare function processSchema(arg: {
+    schema: InternalSchema;
+}): DerivedApiDefinition;