@aws-amplify/data-schema 0.14.1 → 0.14.2

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/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';