@aws-amplify/data-schema 0.13.15 → 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 type { ResolveCustomOperations } from './MappedTypes/CustomOperations';
-export type ClientSchema<Schema extends ModelSchema<any, any>> = InternalClientSchema<Schema>;
+import { ResolveCustomOperations, CustomOperationHandlerTypes } from './MappedTypes/CustomOperations';
+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 & {
+}, 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,13 +1,14 @@
-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';
 import type { RefType, RefTypeParamShape } from '../RefType';
 import type { ResolveRefsOfCustomType, ResolveRefValueArrayTraits } from './ResolveFieldProperties';
+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]>;
@@ -21,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;
 };
 /**
@@ -44,3 +45,78 @@ export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyRes
  * with the addition that allows .ref() a model with custom operations.
  */
 export type ResolveRef<Shape extends RefTypeParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, Link = Shape['link'], RefValue = Link extends keyof FullyResolvedSchema ? FullyResolvedSchema[Link] : Link extends keyof NonModelTypes['enums'] ? NonModelTypes['enums'][Link] : Link extends keyof NonModelTypes['customTypes'] ? ResolveRefsOfCustomType<NonModelTypes, NonModelTypes['customTypes'][Link]> : never, Value = Shape['valueRequired'] extends true ? RefValue : RefValue | null> = ResolveRefValueArrayTraits<Shape, Value>;
+/**
+ * The kind of shape we need to map to custom handler (e.g., lambda) function
+ * signatures.
+ */
+type CustomOperationsMap = Record<string, CustomOperationMinimalDef>;
+/**
+ * The minimal amount of structure needed to extract types for a custom handler.
+ */
+type CustomOperationMinimalDef = {
+    arguments: any;
+    returnType: any;
+};
+/**
+ * Derives the signature and types for a lambda handler for a particular
+ * custom Query or Mutation from a Schema.
+ */
+type IndvidualCustomHandlerTypes<Op extends CustomOperationMinimalDef> = {
+    /**
+     * Handler type for lambda function implementations. E.g.,
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // event and context will be fully typed inside here.
+     * }
+     * ```
+     */
+    functionHandler: AppSyncResolverHandler<Op['arguments'], LambdaReturnType<Op['returnType']>>;
+    /**
+     * The `context.arguments` type for lambda function implementations.
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // Provides this type, if needed:
+     *  const args: Schema['echo']['functionHandlerArguments'] = event.arguments;
+     * }
+     * ```
+     */
+    functionHandlerArguments: Op['arguments'];
+    /**
+     * The return type expected by a lambda function handler.
+     *
+     * ```typescript
+     * import type { Schema } from './resource';
+     *
+     * export const handler: Schema['echo']['functionHandler'] = async (event, context) => {
+     *  // Result type enforced here:
+     *  const result: Schema['echo']['functionHandlerResult'] = buildResult(...);
+     *
+     *  // `Result` type matches expected function return type here:
+     *  return result;
+     * }
+     * ```
+     */
+    functionHandlerResult: LambdaReturnType<Op['returnType']>;
+};
+/**
+ * Derives the function signatures for a lambda handlers for all the provided
+ * custom queries and mutations.
+ */
+export type CustomOperationHandlerTypes<CustomOperations extends CustomOperationsMap> = {
+    [K in keyof CustomOperations]: IndvidualCustomHandlerTypes<CustomOperations[K]>;
+};
+/**
+ * Returns a return type with lazy loaders removed.
+ *
+ * (Custom handlers should not return lazy loaded fields -- they're *lazy loaded*.)
+ */
+type LambdaReturnType<T> = T extends Record<string, any> ? {
+    [K in keyof Exclude<T, null | undefined> as Exclude<T, null | undefined>[K] extends (...args: any) => any ? never : K]: Exclude<T, null | undefined>[K];
+} : T | (null extends T ? null : never) | (undefined extends T ? undefined : never);
+export {};

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));
     };
 }
 /**

package/lib-esm/src/SchemaProcessor.js

@@ -271,6 +271,27 @@ function addFields(existing, additions) {
         }
     }
 }
+/**
+ * Validate that no implicit fields are used by the model definition
+ *
+ * @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 validateStaticFields(existing, implicitFields) {
+    if (implicitFields === undefined) {
+        return;
+    }
+    for (const [k, field] of Object.entries(implicitFields)) {
+        if (!existing[k]) {
+            throw new Error(`Field ${k} isn't defined.`);
+        }
+        else if (areConflicting(existing[k], field)) {
+            throw new Error(`Field ${k} defined twice with conflicting definitions.`);
+        }
+    }
+}
 /**
  * Produces a new field definition object from every field definition object
  * given as an argument. Performs validation (conflict detection) as objects
@@ -721,6 +742,7 @@ const schemaPreprocessor = (schema) => {
     const databaseType = schema.data.configuration.database.engine === 'dynamodb'
         ? 'dynamodb'
         : 'sql';
+    const staticSchema = schema.data.configuration.database.engine === 'dynamodb' ? false : true;
     const fkFields = allImpliedFKs(schema);
     const topLevelTypes = Object.entries(schema.data.types);
     const { schemaAuth, functionSchemaAccess } = extractFunctionSchemaAccess(schema.data.authorization);
@@ -772,6 +794,23 @@ const schemaPreprocessor = (schema) => {
                 }
             }
         }
+        else if (staticSchema) {
+            const fields = { ...typeDef.data.fields };
+            const identifier = typeDef.data.identifier;
+            const [partitionKey] = identifier;
+            validateStaticFields(fields, fkFields[typeName]);
+            const { authString, authFields } = calculateAuth(mostRelevantAuthRules);
+            if (authString == '') {
+                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);
+            validateStaticFields(fields, authFields);
+            const { gqlFields, models } = processFields(typeName, fields, fieldLevelAuthRules, identifier, partitionKey);
+            topLevelTypes.push(...models);
+            const joined = gqlFields.join('\n  ');
+            const model = `type ${typeName} @model ${authString}\n{\n  ${joined}\n}`;
+            gqlModels.push(model);
+        }
         else {
             const fields = mergeFieldObjects(typeDef.data.fields, fkFields[typeName]);
             const identifier = typeDef.data.identifier;