@aws-amplify/data-schema 0.13.16 → 0.13.17

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

@@ -1,34 +1,29 @@
 import { type __modelMeta__ } from '@aws-amplify/data-schema-types';
-import type { ModelSchema } from './ModelSchema';
+import { type GenericModelSchema, type RDSModelSchema } from './ModelSchema';
 import type { ResolveSchema, SchemaTypes } from './MappedTypes/ResolveSchema';
-import type { CreateImplicitModelsFromRelations, ResolveFieldProperties } from './MappedTypes/ResolveFieldProperties';
+import type { CreateImplicitModelsFromRelations, ResolveFieldProperties, ResolveStaticFieldProperties } from './MappedTypes/ResolveFieldProperties';
 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 ModelSchema<any, any>> = InternalClientSchema<Schema>;
+export type ClientSchema<Schema extends GenericModelSchema<any>> = InternalClientSchema<Schema>;
 /**
  * Types for unwrapping generic type args into client-consumable types
  *
- * @typeParam Schema - Type Beast schema type
+ * @typeParam Schema - Data schema builder model type
  *
  * The following params are used solely as variables in order to simplify mapped type usage.
  * They should not receive external type args.
  *
  * @internal @typeParam NonModelTypes - Custom Types, Enums, and Custom Operations
- * @internal @typeParam ResolvedSchema - Schema/Models/Fields structure with generic type args extracted
- * @internal @typeParam ResolvedFields - Resovled client-facing types used for CRUDL response shapes
- * @internal @typeParam IdentifierMeta - Map of model primary index metadata
+ * @internal @typeParam ImplicitModels - The implicit models created to represent relationships
+ * @internal @typeParam ResolvedFields - Resolved client-facing types used for CRUDL response shapes
  * @internal @typeParam SecondaryIndexes - Map of model secondary index metadata
- *
- * @internal @typeParam Meta - Stores schema metadata: identifier, relationship metadata;
- * used by `API.generateClient` to craft strongly typed mutation inputs; hidden from customer-facing types behind __modelMeta__ symbol
- *
  */
-type InternalClientSchema<Schema extends ModelSchema<any, any>, NonModelTypes extends NonModelTypesShape = ExtractNonModelTypes<Schema>, ResolvedSchema = ResolveSchema<Schema>, ImplicitModels = CreateImplicitModelsFromRelations<ResolvedSchema>, ImplicitModelsIdentifierMeta = {
+type InternalClientSchema<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape = ExtractNonModelTypes<Schema>, ResolvedSchema = ResolveSchema<Schema>, ImplicitModels = Schema extends RDSModelSchema<any, any> ? object : CreateImplicitModelsFromRelations<ResolvedSchema>, ImplicitModelsIdentifierMeta = {
     [ImplicitModel in keyof ImplicitModels]: {
         identifier: 'id';
     };
-}, ResolvedFields extends Record<string, unknown> = ResolveFieldProperties<Schema, NonModelTypes, ImplicitModels>, IdentifierMeta extends Record<string, any> = ModelIdentifier<SchemaTypes<Schema>>, SecondaryIndexes extends Record<string, any> = ModelSecondaryIndexes<SchemaTypes<Schema>>> = ResolvedFields & CustomOperationHandlerTypes<ResolveCustomOperations<Schema, ResolvedFields, NonModelTypes>['customOperations']> & ResolvedFields & {
+}, 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>;
 };
 export {};

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

@@ -1,4 +1,4 @@
-import type { ModelSchema } from '../ModelSchema';
+import type { GenericModelSchema } from '../ModelSchema';
 import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 import type { ModelField } from '../ModelField';
@@ -8,7 +8,7 @@ import type { AppSyncResolverHandler } from 'aws-lambda';
 /**
  * Creates meta types for custom operations from a schema.
  */
-export type ResolveCustomOperations<Schema extends ModelSchema<any, any>, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape> = {
+export type ResolveCustomOperations<Schema extends GenericModelSchema<any>, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape> = {
     customOperations: {
         [OpName in keyof CustomOpShapes<Schema>]: {
             arguments: CustomOpArguments<CustomOpShapes<Schema>[OpName]>;
@@ -22,7 +22,7 @@ export type ResolveCustomOperations<Schema extends ModelSchema<any, any>, FullyR
 /**
  * Filtered, mapped list of custom operations shapes from a schema.
  */
-export type CustomOpShapes<Schema extends ModelSchema<any, any>> = {
+export type CustomOpShapes<Schema extends GenericModelSchema<any>> = {
     [K in keyof Schema['data']['types'] as Schema['data']['types'][K] extends CustomOperation<any, any> ? K : never]: Schema['data']['types'][K] extends CustomOperation<infer Shape, any> ? Shape : never;
 };
 /**

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

@@ -2,7 +2,7 @@ import type { UnionToIntersection, LazyLoader, ExcludeEmpty } from '@aws-amplify
 import type { Authorization, ImpliedAuthFields } from '../Authorization';
 import type { ModelField } from '../ModelField';
 import type { ModelType, ModelTypeParamShape } from '../ModelType';
-import type { ModelSchema } from '../ModelSchema';
+import type { GenericModelSchema } from '../ModelSchema';
 import type { ModelRelationalField, ModelRelationalFieldParamShape, ModelRelationalTypeArgFactory, ModelRelationshipTypes } from '../ModelRelationalField';
 import type { AllImpliedFKs } from './ForeignKeys';
 import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
@@ -13,9 +13,10 @@ import type { NonModelTypesShape } from './ExtractNonModelTypes';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
 import type { EnumType, EnumTypeParamShape } from '../EnumType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
-export type ResolveFieldProperties<Schema extends ModelSchema<any, any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, {
+export type ResolveFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, {
     identifier: string;
 }> = ModelIdentifier<SchemaTypes<Schema>>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema & ImplicitModelsSchema, IdentifierMeta>, FieldsWithRelationships = ResolveRelationships<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>, FilterFieldTypes<ModelImpliedAuthFields<Schema>>, AllImpliedFKs<ResolvedSchema, IdentifierMeta>>;
+export type ResolveStaticFieldProperties<Schema extends GenericModelSchema<any>, NonModelTypes extends NonModelTypesShape, ImplicitModelsSchema, ResolvedSchema = ResolveSchema<Schema>, FieldsWithInjectedImplicitFields = InjectImplicitModelFields<ResolvedSchema & ImplicitModelsSchema, object>, FieldsWithRelationships = ResolveRelationships<FieldsWithInjectedImplicitFields, NonModelTypes>> = Intersection<FilterFieldTypes<MarkModelsNonNullableFieldsRequired<FieldsWithRelationships>>, FilterFieldTypes<MarkModelsNullableFieldsOptional<FieldsWithRelationships>>>;
 export type CreateImplicitModelsFromRelations<Schema> = UnionToIntersection<ExcludeEmpty<{
     [ModelProp in keyof Schema]: {
         [FieldProp in keyof Schema[ModelProp] as Schema[ModelProp][FieldProp] extends ModelRelationalFieldParamShape ? Schema[ModelProp][FieldProp]['relationName'] extends string ? Schema[ModelProp][FieldProp]['relationName'] extends keyof Schema ? never : Schema[ModelProp][FieldProp]['relationName'] : never : never]: Record<`${Lowercase<ModelProp & string>}`, ModelRelationalTypeArgFactory<ModelProp & string, ModelRelationshipTypes.hasMany, false>>;
@@ -59,9 +60,9 @@ type MarkModelsNonNullableFieldsRequired<Schema> = {
 type Intersection<A = Record<never, never>, B = Record<never, never>, C = Record<never, never>, D = Record<never, never>> = A & B & C & D extends infer U ? {
     [P in keyof U]: U[P];
 } : never;
-export type ModelImpliedAuthFields<Schema extends ModelSchema<any, any>> = {
+export type ModelImpliedAuthFields<Schema extends GenericModelSchema<any>> = {
     [ModelKey in keyof Schema['data']['types'] as Schema['data']['types'][ModelKey] extends EnumType<EnumTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomType<CustomTypeParamShape> ? never : Schema['data']['types'][ModelKey] extends CustomOperation<CustomOperationParamShape, any> ? never : ModelKey]: Schema['data']['types'][ModelKey] extends ModelType<infer Model, any> ? AllAuthFieldsForModel<Schema, Model> : object;
 };
-type AllAuthFieldsForModel<Schema extends ModelSchema<any, any>, Model extends Schema['data']['types'][keyof Schema['data']['types']]> = (Model['authorization'][number] extends never ? Schema['data']['authorization'][number] extends never ? object : ImpliedAuthFields<Schema['data']['authorization'][number]> : ImpliedAuthFields<Model['authorization'][number]>) & ImpliedAuthFieldsFromFields<Model>;
+type AllAuthFieldsForModel<Schema extends GenericModelSchema<any>, Model extends Schema['data']['types'][keyof Schema['data']['types']]> = (Model['authorization'][number] extends never ? Schema['data']['authorization'][number] extends never ? object : ImpliedAuthFields<Schema['data']['authorization'][number]> : ImpliedAuthFields<Model['authorization'][number]>) & ImpliedAuthFieldsFromFields<Model>;
 type ImpliedAuthFieldsFromFields<T> = UnionToIntersection<T extends ModelTypeParamShape ? T['fields'][keyof T['fields']] extends ModelField<any, any, infer Auth> | ModelRelationalField<any, any, any, infer Auth> | RefType<any, any, infer Auth> ? Auth extends Authorization<any, any, any> ? ImpliedAuthFields<Auth> : object : object : object>;
 export {};

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

@@ -1,5 +1,5 @@
 import type { ModelType } from '../ModelType';
-import type { ModelSchema } from '../ModelSchema';
+import type { GenericModelSchema } from '../ModelSchema';
 import type { ModelRelationalField, ModelRelationshipTypes, RelationTypeFunctionOmitMapping } from '../ModelRelationalField';
 import type { ModelField } from '../ModelField';
 import type { CustomType, CustomTypeParamShape } from '../CustomType';
@@ -7,7 +7,7 @@ import type { EnumType, EnumTypeParamShape } from '../EnumType';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
 export type ResolveSchema<Schema> = FieldTypes<ModelTypes<SchemaTypes<Schema>>>;
-export type SchemaTypes<T> = T extends ModelSchema<any, any> ? T['data']['types'] : never;
+export type SchemaTypes<T> = T extends GenericModelSchema<any> ? T['data']['types'] : never;
 /**
  * Resolves model types
  *

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

@@ -4,6 +4,12 @@ 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 { Brand } from './util';
+export declare const rdsSchemaBrandName = "RDSSchema";
+export declare const rdsSchemaBrand: Brand<"RDSSchema">;
+export type RDSSchemaBrand = Brand<typeof rdsSchemaBrandName>;
+export declare const ddbSchemaBrandName = "DDBSchema";
+export type DDBSchemaBrand = Brand<typeof ddbSchemaBrandName>;
 type SchemaContent = ModelType<ModelTypeParamShape, any> | CustomType<CustomTypeParamShape> | EnumType<EnumTypeParamShape> | CustomOperation<CustomOperationParamShape, any>;
 type ModelSchemaContents = Record<string, SchemaContent>;
 type InternalSchemaModels = Record<string, InternalModel | EnumType<any> | CustomType<any> | InternalCustom>;
@@ -38,7 +44,7 @@ export type ModelSchemaParamShape = {
     authorization: SchemaAuthorization<any, any, any>[];
     configuration: SchemaConfig<any, any>;
 };
-export type SQLModelSchemaParamShape = ModelSchemaParamShape & {
+export type RDSModelSchemaParamShape = ModelSchemaParamShape & {
     setSqlStatementFolderPath?: string;
 };
 export type InternalSchema = {
@@ -48,22 +54,25 @@ export type InternalSchema = {
         configuration: SchemaConfig<any, any>;
     };
 };
-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> & {
+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;
 };
-type SQLModelSchemaFunctions = 'setSqlStatementFolderPath' | 'addQueries' | 'addMutations' | 'addSubscriptions';
-export type SQLModelSchema<T extends SQLModelSchemaParamShape, UsedMethods extends 'authorization' | SQLModelSchemaFunctions = never> = ModelSchema<T, Exclude<UsedMethods, SQLModelSchemaFunctions>> & Omit<{
-    setSqlStatementFolderPath: (path: string) => SQLModelSchema<T, UsedMethods | 'setSqlStatementFolderPath'>;
-    addQueries: (types: Record<string, QueryCustomOperation>) => SQLModelSchema<T, UsedMethods | 'addQueries'>;
-    addMutations: (types: Record<string, MutationCustomOperation>) => SQLModelSchema<T, UsedMethods | 'addMutations'>;
-    addSubscriptions: (types: Record<string, SubscriptionCustomOperation>) => SQLModelSchema<T, UsedMethods | 'addSubscriptions'>;
-}, UsedMethods>;
+export type GenericModelSchema<T extends ModelSchemaParamShape> = BaseSchema<T> & Brand<string>;
+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;
+type RDSModelSchemaFunctions = 'setSqlStatementFolderPath' | 'addQueries' | 'addMutations' | 'addSubscriptions' | 'authorization';
+export type RDSModelSchema<T extends RDSModelSchemaParamShape, UsedMethods extends RDSModelSchemaFunctions = never> = Omit<{
+    setSqlStatementFolderPath: (path: string) => RDSModelSchema<T, UsedMethods | 'setSqlStatementFolderPath'>;
+    addQueries: (types: Record<string, QueryCustomOperation>) => RDSModelSchema<T, UsedMethods | 'addQueries'>;
+    addMutations: (types: Record<string, MutationCustomOperation>) => RDSModelSchema<T, UsedMethods | 'addMutations'>;
+    addSubscriptions: (types: Record<string, SubscriptionCustomOperation>) => RDSModelSchema<T, UsedMethods | 'addSubscriptions'>;
+    authorization: <AuthRules extends SchemaAuthorization<any, any, any>>(auth: AuthRules[]) => RDSModelSchema<SetTypeSubArg<T, 'authorization', AuthRules[]>, UsedMethods | 'authorization'> & RDSSchemaBrand;
+}, UsedMethods> & BaseSchema<T> & RDSSchemaBrand;
 /**
  * Amplify API Next Model Schema shape
  */
@@ -78,7 +87,7 @@ type SchemaReturnType<DE extends DatasourceEngine, Types extends ModelSchemaCont
     types: Types;
     authorization: [];
     configuration: any;
-}> : SQLModelSchema<{
+}> : RDSModelSchema<{
     types: Types;
     authorization: [];
     configuration: any;

package/lib-esm/src/ModelSchema.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.configure = exports.schema = exports.isModelSchema = void 0;
+exports.configure = exports.schema = exports.isModelSchema = exports.ddbSchemaBrandName = exports.rdsSchemaBrand = exports.rdsSchemaBrandName = void 0;
 const ModelType_1 = require("./ModelType");
 const SchemaProcessor_1 = require("./SchemaProcessor");
+const util_1 = require("./util");
+exports.rdsSchemaBrandName = 'RDSSchema';
+exports.rdsSchemaBrand = (0, util_1.brand)(exports.rdsSchemaBrandName);
+exports.ddbSchemaBrandName = 'DDBSchema';
+const ddbSchemaBrand = (0, util_1.brand)(exports.ddbSchemaBrandName);
 /**
  * Filter the schema types down to only include the ModelTypes as SchemaModelType
  *
@@ -29,9 +34,23 @@ const isModelSchema = (schema) => {
     return typeof schema === 'object' && schema.data !== undefined;
 };
 exports.isModelSchema = isModelSchema;
-function _sqlSchemaExtension(schema) {
+function _rdsSchema(types, config) {
+    const data = {
+        types,
+        authorization: [],
+        configuration: config,
+    };
     return {
-        ...schema,
+        data,
+        transform() {
+            const internalSchema = { data };
+            return (0, SchemaProcessor_1.processSchema)({ schema: internalSchema });
+        },
+        authorization(rules) {
+            this.data.authorization = rules;
+            const { authorization: _, ...rest } = this;
+            return rest;
+        },
         setSqlStatementFolderPath(path) {
             this.data.setSqlStatementFolderPath = path;
             const { setSqlStatementFolderPath: _, ...rest } = this;
@@ -52,9 +71,10 @@ function _sqlSchemaExtension(schema) {
             const { addSubscriptions: _, ...rest } = this;
             return rest;
         },
+        ...exports.rdsSchemaBrand,
     };
 }
-function _baseSchema(types, config) {
+function _ddbSchema(types, config) {
     const data = {
         types,
         authorization: [],
@@ -72,13 +92,14 @@ function _baseSchema(types, config) {
             return rest;
         },
         models: filterSchemaModelTypes(data.types),
+        ...ddbSchemaBrand,
     };
 }
 function bindConfigToSchema(config) {
     return (types) => {
         return (config.database.engine === 'dynamodb'
-            ? _baseSchema(types, config)
-            : _sqlSchemaExtension(_baseSchema(types, config)));
+            ? _ddbSchema(types, config)
+            : _rdsSchema(types, config));
     };
 }
 /**