@aws-amplify/data-schema 0.14.1 → 0.14.3

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

@@ -5,7 +5,9 @@ import type { CreateImplicitModelsFromRelations, ResolveFieldProperties, Resolve
 import type { ModelIdentifier, ModelSecondaryIndexes, RelationalMetadata } from './MappedTypes/ModelMetadata';
 import type { ExtractNonModelTypes, NonModelTypesShape } from './MappedTypes/ExtractNonModelTypes';
 import { ResolveCustomOperations, CustomOperationHandlerTypes } from './MappedTypes/CustomOperations';
-export type ClientSchema<Schema extends GenericModelSchema<any>> = InternalClientSchema<Schema>;
+import { CombinedModelSchema, CombinedSchemaIndexesUnion } from './CombineSchema';
+import { SpreadTuple } from './util';
+export type ClientSchema<Schema extends GenericModelSchema<any> | CombinedModelSchema<any>> = Schema extends GenericModelSchema<any> ? InternalClientSchema<Schema> : Schema extends CombinedModelSchema<any> ? InternalCombinedSchema<Schema> : never;
 /**
  * Types for unwrapping generic type args into client-consumable types
  *
@@ -15,8 +17,11 @@ export type ClientSchema<Schema extends GenericModelSchema<any>> = InternalClien
  * They should not receive external type args.
  *
  * @internal @typeParam NonModelTypes - Custom Types, Enums, and Custom Operations
+ * @internal @typeParam ResolvedSchema - Resolve the schema types used by other generics
  * @internal @typeParam ImplicitModels - The implicit models created to represent relationships
+ * @internal @typeParam ImplicitModelsIdentifierMeta - The implicite model identifiers derived from ImplicitModels
  * @internal @typeParam ResolvedFields - Resolved client-facing types used for CRUDL response shapes
+ * @internal @typeParam IdentifierMeta - Resolve the identifier fields for all models
  * @internal @typeParam SecondaryIndexes - Map of model secondary index metadata
  */
 type InternalClientSchema<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape = ExtractNonModelTypes<Schema>, ResolvedSchema = ResolveSchema<Schema>, ImplicitModels = Schema extends RDSModelSchema<any, any> ? object : CreateImplicitModelsFromRelations<ResolvedSchema>, ImplicitModelsIdentifierMeta = {
@@ -26,4 +31,23 @@ type InternalClientSchema<Schema extends GenericModelSchema<any>, NonModelTypes
 }, ResolvedFields extends Record<string, unknown> = Schema extends RDSModelSchema<any, any> ? ResolveStaticFieldProperties<Schema, NonModelTypes, object> : ResolveFieldProperties<Schema, NonModelTypes, ImplicitModels>, IdentifierMeta extends Record<string, any> = ModelIdentifier<SchemaTypes<Schema>>, SecondaryIndexes extends Record<string, any> = Schema extends RDSModelSchema<any, any> ? object : ModelSecondaryIndexes<SchemaTypes<Schema>>> = CustomOperationHandlerTypes<ResolveCustomOperations<Schema, ResolvedFields, NonModelTypes>['customOperations']> & ResolvedFields & {
     [__modelMeta__]: IdentifierMeta & ImplicitModelsIdentifierMeta & SecondaryIndexes & RelationalMetadata<ResolvedSchema, ResolvedFields, IdentifierMeta> & NonModelTypes & ResolveCustomOperations<Schema, ResolvedFields, NonModelTypes>;
 };
+type GetInternalClientSchema<Schema> = Schema extends GenericModelSchema<any> ? InternalClientSchema<Schema> : never;
+type CombinedClientSchemas<Schemas extends CombinedModelSchema<any>['schemas']> = {
+    [Index in keyof Schemas]: Index extends CombinedSchemaIndexesUnion ? GetInternalClientSchema<Schemas[Index]> : never;
+};
+/**
+ * Types for unwrapping and combining generic type args into client-consumable types
+ * for multiple schemas
+ *
+ * @typeParam Combined - A container of multiple schemas
+ *
+ * @internal @typeParam ClientSchemas - The tuple of client schemas to combine
+ */
+type InternalCombinedSchema<Combined extends CombinedModelSchema<any>, ClientSchemas extends [...any] = CombinedClientSchemas<Combined['schemas']>> = SpreadTuple<{
+    [I in keyof ClientSchemas]: I extends CombinedSchemaIndexesUnion ? Exclude<ClientSchemas[I], typeof __modelMeta__> : never;
+}> & {
+    [__modelMeta__]: SpreadTuple<{
+        [I in keyof ClientSchemas]: I extends CombinedSchemaIndexesUnion ? ClientSchemas[I][typeof __modelMeta__] : never;
+    }>;
+};
 export {};

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

@@ -0,0 +1,18 @@
+import { BaseSchema, GenericModelSchema } from './ModelSchema';
+import { Brand, IndexLimitUnion } from './util';
+declare const COMBINED_SCHEMA_LIMIT = 50;
+export type CombinedSchemaIndexesUnion = IndexLimitUnion<typeof COMBINED_SCHEMA_LIMIT>[number];
+declare const CombinedSchemaBrandName = "CombinedSchema";
+export declare const combinedSchemaBrand: Brand<"CombinedSchema">;
+export type CombinedSchemaBrand = Brand<typeof CombinedSchemaBrandName>;
+export type CombinedModelSchema<Schemas extends GenericModelSchema<any>[]> = CombinedSchemaBrand & {
+    schemas: [...Schemas];
+} & BaseSchema<any>;
+/**
+ * The interface for merging up to 50 schemas into a single API.
+ * @param schemas The schemas to combine into a single API
+ * @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 combine<Schema extends GenericModelSchema<any>[]>(schemas: [...Schema]): CombinedModelSchema<Schema>;
+export {};

package/lib-esm/src/CombineSchema.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.combine = exports.combinedSchemaBrand = void 0;
+const util_1 = require("./util");
+const COMBINED_SCHEMA_LIMIT = 50;
+const CombinedSchemaBrandName = 'CombinedSchema';
+exports.combinedSchemaBrand = (0, util_1.brand)(CombinedSchemaBrandName);
+/**
+ * The interface for merging up to 50 schemas into a single API.
+ * @param schemas The schemas to combine into a single API
+ * @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 combine(schemas) {
+    return internalCombine(schemas);
+}
+exports.combine = combine;
+function internalCombine(schemas) {
+    return {
+        schemas: schemas,
+        data: {
+            types: schemas.reduce((prev, schema) => ({ ...prev, ...schema.data.types }), {}),
+        },
+        models: schemas.reduce((prev, schema) => ({ ...prev, ...schema.models }), {}),
+        transform() {
+            const baseDefinition = {
+                functionSlots: [],
+                jsFunctions: [],
+                schema: '',
+                functionSchemaAccess: [],
+                lambdaFunctions: {},
+            };
+            return schemas.reduce((prev, schema) => {
+                const transformedSchema = schema.transform();
+                return {
+                    functionSlots: [
+                        ...prev.functionSlots,
+                        ...transformedSchema.functionSlots,
+                    ],
+                    jsFunctions: [...prev.jsFunctions, ...transformedSchema.jsFunctions],
+                    schema: [prev.schema, transformedSchema.schema].join('\n'),
+                    functionSchemaAccess: [
+                        ...prev.functionSchemaAccess,
+                        ...transformedSchema.functionSchemaAccess,
+                    ],
+                    lambdaFunctions: {
+                        ...prev.lambdaFunctions,
+                        ...transformedSchema.lambdaFunctions,
+                    },
+                };
+            }, baseDefinition);
+        },
+        ...exports.combinedSchemaBrand,
+    };
+}

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

@@ -54,14 +54,14 @@ export type InternalSchema = {
         configuration: SchemaConfig<any, any>;
     };
 };
-type BaseSchema<T extends ModelSchemaParamShape> = {
+export type BaseSchema<T extends ModelSchemaParamShape> = {
     data: T;
     models: {
         [TypeKey in keyof T['types']]: T['types'][TypeKey] extends ModelType<ModelTypeParamShape> ? SchemaModelType<T['types'][TypeKey]> : never;
     };
     transform: () => DerivedApiDefinition;
 };
-export type GenericModelSchema<T extends ModelSchemaParamShape> = BaseSchema<T> & Brand<string>;
+export type GenericModelSchema<T extends ModelSchemaParamShape> = BaseSchema<T> & Brand<typeof rdsSchemaBrandName | typeof ddbSchemaBrandName>;
 export type ModelSchema<T extends ModelSchemaParamShape, UsedMethods extends 'authorization' = never> = Omit<{
     authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(auth: AuthRules[]) => ModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'>;
 }, UsedMethods> & BaseSchema<T> & DDBSchemaBrand;

package/lib-esm/src/SchemaProcessor.js

@@ -198,7 +198,7 @@ function customOperationToGql(typeName, typeDef, authorization, isCustom = false
         throw new Error(`Unrecognized return type on ${typeName}`);
     }
     if (Object.keys(fieldArgs).length > 0) {
-        const { gqlFields, models } = processFields(typeName, fieldArgs, {});
+        const { gqlFields, models } = processFields(typeName, fieldArgs, {}, {});
         callSignature += `(${gqlFields.join(', ')})`;
         implicitModels.push(...models);
     }
@@ -307,6 +307,24 @@ function validateStaticFields(existing, implicitFields) {
         }
     }
 }
+/**
+ * Validate that no implicit fields conflict with explicitly defined fields.
+ *
+ * @param existing An existing field map
+ * @param implicitFields A field map inferred from other schema usage
+ *
+ * @throws An error when an undefined field is used or when a field is used in a way that conflicts with its generated definition
+ */
+function validateImpliedFields(existing, implicitFields) {
+    if (implicitFields === undefined) {
+        return;
+    }
+    for (const [k, field] of Object.entries(implicitFields)) {
+        if (existing[k] && areConflicting(existing[k], field)) {
+            throw new Error(`Implicit field ${k} conflicts with the explicit field definition.`);
+        }
+    }
+}
 /**
  * Produces a new field definition object from every field definition object
  * given as an argument. Performs validation (conflict detection) as objects
@@ -344,7 +362,8 @@ function validateAuth(authorization = []) {
  *
  * The computed directives are intended to be appended to the graphql field definition.
  *
- * The computed fields are intended to be aggregated and injected per model.
+ * The computed fields will be used to confirm no conflicts between explicit field definitions
+ * and implicit auth fields.
  *
  * @param authorization A list of authorization rules.
  * @returns
@@ -590,35 +609,6 @@ const allImpliedFKs = (schema) => {
     }
     return fks;
 };
-/**
- * Determines if implicit date fields are in effect for a given model. If they are,
- * returns those implicit fields.
- *
- * NOTE: For now, we *only* support the default implicit fields.
- *
- * @param _model Model to find date fields for.
- */
-const implicitTimestampFields = (_model) => {
-    return {
-        createdAt: (0, ModelField_1.datetime)().required(),
-        updatedAt: (0, ModelField_1.datetime)().required(),
-    };
-};
-/**
- * Generates default Pk fields for a model, based on identifier designation.
- *
- * The fields from this function are just default values. They should be overridden
- * by ID field definitions that are explicit in the model.
- *
- * @param _model Model to find PK fields for.
- */
-const idFields = (model) => {
-    const fields = {};
-    for (const fieldName of model.data.identifier) {
-        fields[fieldName] = (0, ModelField_1.id)().required();
-    }
-    return fields;
-};
 function processFieldLevelAuthRules(fields, authFields) {
     const fieldLevelAuthRules = {};
     for (const [fieldName, fieldDef] of Object.entries(fields)) {
@@ -633,9 +623,10 @@ function processFieldLevelAuthRules(fields, authFields) {
     }
     return fieldLevelAuthRules;
 }
-function processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey, secondaryIndexes = {}) {
+function processFields(typeName, fields, impliedFields, fieldLevelAuthRules, identifier, partitionKey, secondaryIndexes = {}) {
     const gqlFields = [];
     const models = [];
+    validateImpliedFields(fields, impliedFields);
     for (const [fieldName, fieldDef] of Object.entries(fields)) {
         const fieldAuth = fieldLevelAuthRules[fieldName]
             ? ` ${fieldLevelAuthRules[fieldName]}`
@@ -806,7 +797,7 @@ const schemaPreprocessor = (schema) => {
                 const authString = '';
                 const authFields = {};
                 const fieldLevelAuthRules = processFieldLevelAuthRules(fieldAuthApplicableFields, authFields);
-                const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules);
+                const { gqlFields, models } = processFields(typeName, fields, authFields, fieldLevelAuthRules);
                 topLevelTypes.push(...models);
                 const joined = gqlFields.join('\n  ');
                 const model = `type ${typeName} ${authString}\n{\n  ${joined}\n}`;
@@ -846,7 +837,7 @@ const schemaPreprocessor = (schema) => {
             }
             const fieldLevelAuthRules = processFieldLevelAuthRules(fields, authFields);
             validateStaticFields(fields, authFields);
-            const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey);
+            const { gqlFields, models } = processFields(typeName, fields, authFields, fieldLevelAuthRules, identifier, partitionKey);
             topLevelTypes.push(...models);
             const joined = gqlFields.join('\n  ');
             const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;
@@ -862,14 +853,7 @@ const schemaPreprocessor = (schema) => {
                 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(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
-                // to whatever is explicitly defined if there's an overlap.
-                ...idFields(typeDef),
-                ...mergeFieldObjects(fields, authFields, implicitTimestampFields(typeDef)),
-            }, fieldLevelAuthRules, identifier, partitionKey, transformedSecondaryIndexes);
+            const { gqlFields, models } = processFields(typeName, fields, authFields, fieldLevelAuthRules, identifier, partitionKey, transformedSecondaryIndexes);
             topLevelTypes.push(...models);
             const joined = gqlFields.join('\n  ');
             const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;

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

@@ -1,4 +1,5 @@
 import { schema } from './ModelSchema';
+import { combine } from './CombineSchema';
 import { model } from './ModelType';
 import { id, string, integer, float, boolean, date, time, datetime, timestamp, email, json, phone, url, ipAddress } from './ModelField';
 import { ref } from './RefType';
@@ -8,4 +9,4 @@ import { customType } from './CustomType';
 import { enumType } from './EnumType';
 import { query, mutation, subscription } from './CustomOperation';
 import { handler } from './Handler';
-export { schema, model, 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, };
+export { schema, combine, model, 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, };

package/lib-esm/src/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handler = 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.allow = exports.manyToMany = exports.belongsTo = exports.hasMany = exports.hasOne = exports.subscription = exports.mutation = exports.query = exports.enum = exports.customType = exports.ref = exports.model = exports.schema = void 0;
+exports.handler = 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.allow = exports.manyToMany = exports.belongsTo = exports.hasMany = exports.hasOne = exports.subscription = exports.mutation = exports.query = exports.enum = exports.customType = exports.ref = exports.model = exports.combine = exports.schema = void 0;
 const ModelSchema_1 = require("./ModelSchema");
 Object.defineProperty(exports, "schema", { enumerable: true, get: function () { return ModelSchema_1.schema; } });
+const CombineSchema_1 = require("./CombineSchema");
+Object.defineProperty(exports, "combine", { enumerable: true, get: function () { return CombineSchema_1.combine; } });
 const ModelType_1 = require("./ModelType");
 Object.defineProperty(exports, "model", { enumerable: true, get: function () { return ModelType_1.model; } });
 const ModelField_1 = require("./ModelField");

package/lib-esm/src/util/IndexLimit.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Create a type literal of numbers as index strings
+ * The resulting literal will include 0 up to (N - 1)
+ *
+ * @typeParam N - The number of literal values to include
+ */
+export type IndexLimitUnion<N extends number, Result extends Array<unknown> = []> = Result['length'] extends N ? Result : IndexLimitUnion<N, [...Result, `${Result['length']}`]>;

package/lib-esm/src/util/IndexLimit.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib-esm/src/util/SpreadTuple.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Transform into the type intersection of all items in a given tuple
+ *
+ * @typeParam T - The tuple of types to spread into a type intersection
+ */
+export type SpreadTuple<T extends readonly any[]> = T extends [infer F] ? F : T extends [infer F, ...infer R] ? F & SpreadTuple<R> : never;

package/lib-esm/src/util/SpreadTuple.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1 +1,3 @@
 export { Brand, brand, getBrand } from './Brand';
+export { IndexLimitUnion } from './IndexLimit';
+export { SpreadTuple } from './SpreadTuple';