@aws-amplify/data-schema 0.11.0

package/lib-esm/src/Authorization.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accessData = exports.allow = exports.Operations = exports.Strategies = exports.CustomProviders = exports.GroupProviders = exports.OwnerProviders = exports.PrivateProviders = exports.PublicProviders = exports.Providers = void 0;
+const __data = Symbol('data');
+/**
+ * All possible providers.
+ *
+ * This list should not be used if you need to restrict available providers
+ * according to an auth strategcy. E.g., `public` auth can only be facilitated
+ * by `apiKey` and `iam` providers.
+ */
+exports.Providers = [
+    'apiKey',
+    'iam',
+    'userPools',
+    'oidc',
+    'function',
+];
+/**
+ * The subset of auth providers that can facilitate `public` auth.
+ */
+exports.PublicProviders = ['apiKey', 'iam'];
+/**
+ * The subset of auth providers that can facilitate `private` auth.
+ */
+exports.PrivateProviders = ['userPools', 'oidc', 'iam'];
+/**
+ * The subset of auth providers that can facilitate `owner` auth.
+ */
+exports.OwnerProviders = ['userPools', 'oidc'];
+/**
+ * The subset of auth providers that can facilitate `group` auth.
+ */
+exports.GroupProviders = ['userPools', 'oidc'];
+/**
+ * The subset of auth providers that can facilitate `custom` auth.
+ */
+exports.CustomProviders = ['function'];
+exports.Strategies = [
+    'public',
+    'private',
+    'owner',
+    'groups',
+    'custom',
+];
+/**
+ * The operations that can be performed against an API.
+ */
+exports.Operations = [
+    'create',
+    'update',
+    'delete',
+    'read',
+    'get',
+    'list',
+    'sync',
+    'listen',
+    'search',
+];
+/**
+ * Creates a shallow copy of an object with an individual field pruned away.
+ *
+ * @param original The original object to prune.
+ * @param without The field to prune.
+ * @returns The pruned object.
+ */
+function omit(original, without) {
+    const pruned = { ...original };
+    delete pruned[without];
+    return pruned;
+}
+function to(operations) {
+    this[__data].operations = operations;
+    return omit(this, 'to');
+}
+function inField(field) {
+    this[__data].groupOrOwnerField = field;
+    const built = omit(this, 'inField');
+    return built;
+}
+/**
+ * Specifies a property of the identity JWT to use in place of `sub::username`
+ * as the value to match against the owner field for authorization.
+ *
+ * @param this Authorization object to operate against.
+ * @param property A property of identity JWT.
+ * @returns A copy of the Authorization object with the claim attached.
+ */
+function identityClaim(property) {
+    this[__data].identityClaim = property;
+    return omit(this, 'identityClaim');
+}
+function withClaimIn(property) {
+    this[__data].groupClaim = property;
+    return omit(this, 'withClaimIn');
+}
+function validateProvider(needle, haystack) {
+    if (needle && !haystack.includes(needle)) {
+        throw new Error(`Invalid provider (${needle}) given!`);
+    }
+}
+function authData(defaults, builderMethods) {
+    return {
+        [__data]: {
+            strategy: 'public',
+            provider: undefined,
+            operations: undefined,
+            groupOrOwnerField: undefined,
+            multiOwner: false,
+            identityClaim: undefined,
+            groups: undefined,
+            ...defaults,
+            // might not even be needed ...
+            // dependencies: {
+            //   owner: {},
+            // },
+        },
+        ...builderMethods,
+    };
+}
+/**
+ * Defines an authorization rule for your data models and fields. First choose an authorization strategy (`public`,
+ * `private`, `owner`, `group`, or `custom`), then choose an auth provider (`apiKey`, `iam`, `userPools`, `oidc`, or `function`)
+ * and optionally use `.to(...)` to specify the operations that can be performed against your data models and fields.
+ */
+exports.allow = {
+    /**
+     * Authorize unauthenticated users. By default, `.public()` uses an API key based authorization. You can additionally
+     * use `.public('iam')` to use IAM based authorization for unauthenticated users.
+     * @param provider the authentication provider - supports "apiKey" or "iam" as valid providers
+     * @returns an authorization rule for unauthenticated users
+     */
+    public(provider) {
+        validateProvider(provider, exports.PublicProviders);
+        return authData({
+            strategy: 'public',
+            provider,
+        }, {
+            to,
+        });
+    },
+    /**
+     * Authorize authenticated users. By default, `.private()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.private("iam")` or `.private("oidc")` to use IAM or OIDC based authorization for authenticated users.
+     * @param provider the authentication provider - supports "userPools", "iam", or "oidc"
+     * @returns an authorization rule for authenticated users
+     */
+    private(provider) {
+        validateProvider(provider, exports.PrivateProviders);
+        return authData({
+            strategy: 'private',
+            provider,
+        }, {
+            to,
+        });
+    },
+    /**
+     * Authorize access on a per-user (owner) basis. By setting owner-based authorization, a new `owner: a.string()`
+     * field will be added to the model to store which user "owns" the item. Upon item creation, the "owner field" is
+     * auto-populated with the authenticated user's information. You can which field should be used as the owner field
+     * by chaining the * `.inField(...)` method.
+     *
+     * By default, `.owner()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.owner("oidc")` to use OIDC based authentication to designate the owner.
+     *
+     * To change the specific claim that should be used as the user identifier within the owner field, chain the
+     * `.identityClaim(...)` method.
+     *
+     * @param provider the authentication provider - supports "userPools", "iam", or "oidc"
+     * @returns an authorization rule for authenticated users
+     */
+    owner(provider) {
+        validateProvider(provider, exports.OwnerProviders);
+        return authData({
+            strategy: 'owner',
+            provider,
+            groupOrOwnerField: 'owner',
+        }, {
+            to,
+            inField,
+            identityClaim,
+        });
+    },
+    /**
+     * Authorize access for multi-user / multi-owner access. By setting multi-owner-based authorization, a new `owners: a.string().array()`
+     * field will be added to the model to store which users "own" the item. Upon item creation, the "owners field" is
+     * auto-populated with the authenticated user's information. To grant other users access to the item, append their user identifier into the `owners` array.
+     * You can which field should be used as the owners field by chaining the * `.inField(...)` method.
+     *
+     * By default, `.multipleOwners()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.multipleOwners("oidc")` to use OIDC based authentication to designate the owner.
+     *
+     * To change the specific claim that should be used as the user identifier within the owners field, chain the
+     * `.identityClaim(...)` method.
+     *
+     * @param provider the authentication provider - supports "userPools", "iam", or "oidc"
+     * @returns an authorization rule for authenticated users
+     */
+    multipleOwners(provider) {
+        validateProvider(provider, exports.OwnerProviders);
+        return authData({
+            strategy: 'owner',
+            multiOwner: true,
+            provider,
+            groupOrOwnerField: 'owner',
+        }, {
+            to,
+            inField,
+            identityClaim,
+        });
+    },
+    /**
+     * Authorize a specific user group. Provide the name of the specific user group to have access.
+     *
+     * By default, `.specificGroup()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.specificGroup("oidc")` to use OIDC based authentication to designate the user group.
+     *
+     * To change the specific claim that should be used as the user group identifier, chain the
+     * `.groupClaim(...)` method.
+     * @param group the name of the group to authorize
+     * @param provider the authentication provider - supports "userPools" or "oidc"
+     * @returns an authorization rule to grant access by a specific group
+     */
+    specificGroup(group, provider) {
+        return authData({
+            strategy: 'groups',
+            provider,
+            groups: [group],
+        }, {
+            to,
+            withClaimIn,
+        });
+    },
+    /**
+     * Authorize multiple specific user groups. Provide the names of the specific user groups to have access.
+     *
+     * By default, `.specificGroups()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.specificGroups("oidc")` to use OIDC based authentication to designate the user group.
+     *
+     * To change the specific claim that should be used as the user group identifier, chain the
+     * `.groupClaim(...)` method.
+     * @param groups the names of the group to authorize defined as an array
+     * @param provider the authentication provider - supports "userPools" or "oidc"
+     * @returns an authorization rule to grant access by a specific group
+     */
+    specificGroups(groups, provider) {
+        return authData({
+            strategy: 'groups',
+            provider,
+            groups,
+        }, {
+            to,
+            withClaimIn,
+        });
+    },
+    /**
+     * Authorize if a user is part of a group defined in a data model field.
+     *
+     * By default, `.groupDefinedIn()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.groupDefinedIn("oidc")` to use OIDC based authentication to designate the user group.
+     *
+     * To change the specific claim that should be used as the user group identifier within the groups field, chain the
+     * `.groupClaim(...)` method.
+     * @param groupsField the field that should store the authorized user group information
+     * @param provider the authentication provider - supports "userPools" or "oidc"
+     * @returns an authorization rule to grant access by a specific group
+     */
+    groupDefinedIn(groupsField, provider) {
+        return authData({
+            strategy: 'groups',
+            provider,
+            groupOrOwnerField: groupsField,
+        }, {
+            to,
+        });
+    },
+    /**
+     * Authorize if a user is part of a one of the groups defined in a data model field.
+     *
+     * By default, `.groupsDefinedIn()` uses an Amazon Cognito user pool based authorization. You can additionally
+     * use `.groupsDefinedIn("oidc")` to use OIDC based authentication to designate the user group.
+     *
+     * To change the specific claim that should be used as the user group identifier within the groups field, chain the
+     * `.groupClaim(...)` method.
+     * @param groupsField the field that should store the list of authorized user groups
+     * @param provider the authentication provider - supports "userPools" or "oidc"
+     * @returns an authorization rule to grant access by a specific group
+     */
+    groupsDefinedIn(groupsField, provider) {
+        return authData({
+            strategy: 'groups',
+            provider,
+            groupOrOwnerField: groupsField,
+            multiOwner: true,
+        }, {
+            to,
+        });
+    },
+    custom(provider) {
+        return authData({
+            strategy: 'custom',
+            provider,
+        }, {
+            to,
+        });
+    },
+};
+const accessData = (authorization) => authorization[__data];
+exports.accessData = accessData;

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

@@ -0,0 +1,27 @@
+import { type Prettify, __modelMeta__ } from '@aws-amplify/data-schema-types';
+import type { ModelSchema } from './ModelSchema';
+import type { ResolveSchema, SchemaTypes } from './MappedTypes/ResolveSchema';
+import type { ResolveFieldProperties } from './MappedTypes/ResolveFieldProperties';
+import type { ModelIdentifier, RelationalMetadata } from './MappedTypes/ModelMetadata';
+import type { ExtractNonModelTypes, NonModelTypesShape } from './MappedTypes/ExtractNonModelTypes';
+export type ClientSchema<Schema extends ModelSchema<any>> = InternalClientSchema<Schema>;
+/**
+ * Types for unwrapping generic type args into client-consumable types
+ *
+ * @typeParam Schema - Type Beast schema 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 ResolvedSchema - Schema/Models/Fields structure with generic type args extracted
+ * @internal @typeParam IdentifierMeta - Stores model identifier
+ * @internal @typeParam ResolvedFields - optionality enforced on nullable types (+?); These are the client-facing types used for CRUDL response shapes
+ *
+ * @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>, NonModelTypes extends NonModelTypesShape = ExtractNonModelTypes<Schema>, ResolvedSchema = ResolveSchema<Schema>, IdentifierMeta extends Record<string, any> = ModelIdentifier<SchemaTypes<Schema>>, ResolvedFields extends Record<string, unknown> = ResolveFieldProperties<Schema, NonModelTypes>, RelationshipMeta = RelationalMetadata<ResolvedSchema, ResolvedFields, IdentifierMeta>, Meta = IdentifierMeta & RelationshipMeta & NonModelTypes> = Prettify<ResolvedFields & {
+    [__modelMeta__]: Meta;
+}>;
+export {};

package/lib-esm/src/ClientSchema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_schema_types_1 = require("@aws-amplify/data-schema-types");

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

@@ -0,0 +1,33 @@
+import { Brand } from '@aws-amplify/data-schema-types';
+import { ModelField, InternalField, ModelFieldTypeParamOuter } from './ModelField';
+/**
+ * Custom Types
+ *
+ * can be defined in-line to strongly type object types
+ *
+ */
+export type CustomTypeAllowedModifiers = 'authorization' | 'array' | 'required';
+type ModelFields = Record<string, ModelField<ModelFieldTypeParamOuter, CustomTypeAllowedModifiers, any>>;
+type InternalModelFields = Record<string, InternalField>;
+type CustomTypeData = {
+    fields: ModelFields;
+    type: 'customType';
+};
+type InternalCustomTypeData = CustomTypeData & {
+    fields: InternalModelFields;
+};
+export type CustomTypeParamShape = {
+    fields: ModelFields;
+};
+export type CustomType<T extends CustomTypeParamShape> = Brand<T, 'customType'>;
+/**
+ * Internal representation of CustomType that exposes the `data` property.
+ * Used at buildtime.
+ */
+export type InternalCustomType = CustomType<any> & {
+    data: InternalCustomTypeData;
+};
+export declare function customType<T extends ModelFields>(fields: T): CustomType<{
+    fields: T;
+}>;
+export {};

package/lib-esm/src/CustomType.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customType = void 0;
+function _customType(fields) {
+    const data = {
+        fields,
+        type: 'customType',
+    };
+    return { data };
+}
+function customType(fields) {
+    return _customType(fields);
+}
+exports.customType = customType;

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

@@ -0,0 +1,15 @@
+import { Brand } from '@aws-amplify/data-schema-types';
+export type EnumTypeParamShape = {
+    type: 'enum';
+    values: readonly string[];
+};
+export type EnumType<T extends EnumTypeParamShape> = Brand<T, 'enum'>;
+type EnumTypeArgFactory<Values extends readonly string[]> = {
+    type: 'enum';
+    values: Values;
+};
+/**
+ * this type param pattern allows us to infer literal type values from the array without using the `as const` suffix
+ */
+export declare function enumType<Value extends string, T extends readonly Value[]>(values: T): EnumType<EnumTypeArgFactory<T>>;
+export {};

package/lib-esm/src/EnumType.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumType = void 0;
+function _enum(values) {
+    const data = {
+        type: 'enum',
+        values,
+    };
+    return data;
+}
+/**
+ * this type param pattern allows us to infer literal type values from the array without using the `as const` suffix
+ */
+function enumType(values) {
+    return _enum(values);
+}
+exports.enumType = enumType;

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

@@ -0,0 +1,32 @@
+import type { CustomType, CustomTypeParamShape } from '../CustomType';
+import type { EnumType, EnumTypeParamShape } from '../EnumType';
+import type { SchemaTypes, ModelTypes } from './ResolveSchema';
+import type { ModelField } from '../ModelField';
+export type NonModelTypesShape = {
+    enums: Record<string, EnumType<any>>;
+    customTypes: Record<string, any>;
+};
+export type ExtractNonModelTypes<Schema> = ResolveNonModelFields<ResolveNonModelTypes<Schema, ExtractImplicitNonModelTypes<Schema>>>;
+/**
+ * Pulls out implicit, i.e. field-level non-model types from Schema
+ */
+type ExtractImplicitNonModelTypes<Schema, ResolvedModels = ModelTypes<SchemaTypes<Schema>>, ResolvedModelKeys extends keyof ResolvedModels = keyof ResolvedModels> = {
+    [Field in keyof ResolvedModels[ResolvedModelKeys] as ResolvedModels[ResolvedModelKeys][Field] extends EnumType<EnumTypeParamShape> ? `${Capitalize<Field & string>}` : ResolvedModels[ResolvedModelKeys][Field] extends CustomType<CustomTypeParamShape> ? `${Capitalize<Field & string>}` : never]: ResolvedModels[ResolvedModelKeys][Field];
+};
+type ResolveNonModelTypes<Schema, Extracted, ResolvedSchema = SchemaTypes<Schema> & Extracted> = {
+    enums: {
+        [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends EnumType<EnumTypeParamShape> ? Model : never]: ResolvedSchema[Model] extends EnumType<infer R extends EnumTypeParamShape> ? R['values'][number] : never;
+    };
+    customTypes: {
+        [Model in keyof ResolvedSchema as ResolvedSchema[Model] extends CustomType<CustomTypeParamShape> ? Model : never]: ResolvedSchema[Model] extends CustomType<infer R extends CustomTypeParamShape> ? R['fields'] : never;
+    };
+};
+type ResolveNonModelFields<T extends NonModelTypesShape, CustomTypes = T['customTypes']> = {
+    enums: T['enums'];
+    customTypes: {
+        [CustomType in keyof CustomTypes]: {
+            [FieldProp in keyof CustomTypes[CustomType]]: CustomTypes[CustomType][FieldProp] extends ModelField<infer R, any, any> ? R : never;
+        };
+    };
+};
+export {};

package/lib-esm/src/MappedTypes/ExtractNonModelTypes.js

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

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

@@ -0,0 +1,83 @@
+import { ResolveSchema } from './ResolveSchema';
+import { Prettify, UnionToIntersection } from '@aws-amplify/data-schema-types';
+import { ModelRelationalFieldParamShape, ModelRelationshipTypes } from '../ModelRelationalField';
+export type AllImpliedFKs<ResolvedSchema, Identifiers extends Record<string, {
+    identifier: string;
+}>, Schema extends Record<any, any> = ResolvedSchema extends ResolveSchema<any> ? ResolvedSchema : object, DenormalizedSchema extends Denormalized<Schema, Identifiers> = Denormalized<Schema, Identifiers>, AllModels = DenormalizedSchema['model'] | DenormalizedSchema['relationName']> = {
+    [K in Extract<AllModels, string>]: ImpliedFKs<ResolvedSchema, Identifiers, K> extends never ? object : ImpliedFKs<ResolvedSchema, Identifiers, K>;
+};
+export type Denormalized<Schema extends Record<any, any>, Identifiers extends Record<string, {
+    identifier: string;
+}>> = {
+    [ModelName in keyof Schema]: {
+        [FieldName in keyof Schema[ModelName]]: Prettify<{
+            model: ModelName;
+            identifier: IdentifierFields<Identifiers, ModelName>;
+            field: FieldName;
+            type: Schema[ModelName][FieldName];
+        } & RelatedModelFields<Schema[ModelName][FieldName], Identifiers>>;
+    }[keyof Schema[ModelName]];
+}[keyof Schema];
+export type ImpliedFKs<ResolvedSchema, Identifiers extends Record<string, {
+    identifier: string;
+}>, ModelName, Schema extends Record<any, any> = ResolvedSchema extends ResolveSchema<any> ? ResolvedSchema : object, DenormalizedSchema = Denormalized<Schema, Identifiers>, HasMany_Model = Extract<DenormalizedSchema, {
+    relatedModel: ModelName;
+    relationshipType: ModelRelationshipTypes.hasMany;
+}>, HasOne_Model = Extract<DenormalizedSchema, {
+    model: ModelName;
+    relationshipType: ModelRelationshipTypes.hasOne;
+}>, Model_BelongsTo = Exclude<Extract<DenormalizedSchema, {
+    model: ModelName;
+    relationshipType: ModelRelationshipTypes.belongsTo;
+}>, ImpliedHasManyBelongsTos<HasMany_Model>>, ManyToManys = Extract<DenormalizedSchema, {
+    relationName: ModelName;
+    relationshipType: ModelRelationshipTypes.manyToMany;
+}>, InferredFields = HasMany_Model_Keys<Schema, HasMany_Model> | HasOne_Model_Keys<Schema, HasOne_Model> | Model_BelongsTo_Keys<Schema, Model_BelongsTo> | ManyToManyKeys<Schema, ManyToManys>> = unknown extends UnionToIntersection<InferredFields> ? never : Prettify<UnionToIntersection<InferredFields>>;
+type IdentifierFields<Identifiers extends Record<string, {
+    identifier: string;
+}>, ModelName> = ModelName extends keyof Identifiers ? Identifiers[ModelName]['identifier'] : 'id';
+type RelatedModelFields<ModelField, Identifiers extends Record<string, {
+    identifier: string;
+}>> = ModelField extends ModelRelationalFieldParamShape ? {
+    relatedModel: ModelField['relatedModel'];
+    relationshipType: ModelField['relationshipType'];
+    relationName: ModelField['relationName'];
+    relatedModelIdentifier: IdentifierFields<Identifiers, ModelField['relatedModel']>;
+} : {
+    relatedModel: undefined;
+    relationshipType: undefined;
+    relationName: undefined;
+    relatedModelIdentifier: never;
+};
+type FieldWithRelationship = {
+    model: string;
+    identifier: string;
+    field: string;
+    relatedModel: string;
+    relatedModelIdentifier: string;
+    relationName: string | undefined;
+};
+/**
+ * I.e., creates a "matcher" to identify the belongsTo entries that correspond with
+ * the given hasMany relationship.
+ *
+ * The `belongsTo` side of these relationships can be ignored. The FK comes from the
+ * `hasMany` side of the relationship.
+ */
+type ImpliedHasManyBelongsTos<Relationship> = Relationship extends FieldWithRelationship ? {
+    model: Relationship['relatedModel'];
+} : never;
+type FKName<Model extends string, Field extends string, Identifier extends string> = `${Uncapitalize<Model>}${Capitalize<Field>}${Capitalize<Identifier>}`;
+type HasMany_Model_Keys<Schema extends Record<any, any>, RelDef> = RelDef extends FieldWithRelationship ? {
+    [IDField in RelDef['identifier'] as FKName<RelDef['model'], RelDef['field'], IDField>]?: IDField extends keyof Schema[RelDef['model']] ? Schema[RelDef['model']][IDField] : string;
+} : never;
+type HasOne_Model_Keys<Schema extends Record<any, any>, RelDef> = RelDef extends FieldWithRelationship ? {
+    [IDField in RelDef['relatedModelIdentifier'] as FKName<RelDef['model'], RelDef['field'], IDField>]?: IDField extends keyof Schema[RelDef['relatedModel']] ? Schema[RelDef['relatedModel']][IDField] : string;
+} : never;
+type Model_BelongsTo_Keys<Schema extends Record<any, any>, RelDef> = RelDef extends FieldWithRelationship ? {
+    [IDField in RelDef['relatedModelIdentifier'] as FKName<RelDef['model'], RelDef['field'], IDField>]?: IDField extends keyof Schema[RelDef['model']] ? Schema[RelDef['model']][IDField] : string;
+} : never;
+type ManyToManyKeys<Schema extends Record<any, any>, RelDef> = RelDef extends FieldWithRelationship ? {
+    [IDField in RelDef['identifier'] as FKName<RelDef['model'], '', IDField>]?: IDField extends keyof Schema[RelDef['model']] ? Schema[RelDef['model']][IDField] : string;
+} : never;
+export {};

package/lib-esm/src/MappedTypes/ForeignKeys.js

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

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

@@ -0,0 +1,37 @@
+type DefaultIdentifierFields = {
+    readonly id: string;
+};
+type DefaultTimestampFields = {
+    readonly createdAt: string;
+    readonly updatedAt: string;
+};
+type InitialImplicitFields<Identifier> = Identifier extends 'id' ? DefaultIdentifierFields & DefaultTimestampFields : DefaultTimestampFields;
+/**
+ * @returns true if a string union `ExplicitFieldNames` contains a given string `FieldName`
+ */
+type FieldExists<ExplicitFieldNames extends string, FieldName extends string> = Extract<ExplicitFieldNames, FieldName> extends never ? false : true;
+/**
+ * @returns union of explicitly defined field names for a model
+ */
+type GetModelFieldNames<FlatModel> = FlatModel extends Record<infer R, any> ? R : never;
+/**
+ * Generate Record type containing all implicit fields for a given model
+ */
+type ImplicitFields<FlatModel, Identifier, ModelFieldNames = GetModelFieldNames<FlatModel>> = {
+    [ImplicitField in keyof InitialImplicitFields<Identifier> as FieldExists<ModelFieldNames & string, ImplicitField & string> extends true ? never : ImplicitField]: InitialImplicitFields<Identifier>[ImplicitField];
+};
+/**
+ * @returns intersection of explicit and implicit model fields
+ */
+type InjectDefaultFieldsForModel<FlatModel, ModelIdentifier> = FlatModel & ImplicitFields<FlatModel, 'identifier' extends keyof ModelIdentifier ? ModelIdentifier['identifier'] : never>;
+/**
+ * Mapped type that injects default implicit fields for a model
+ * 1. Add "id" field to models with neither an explicit field named "id" nor a custom identifier (`.identifier(['some-field'])`)
+ * 2. Add default timestamp fields ("createdAt", "updatedAt") unless they're already explicitly defined
+ *
+ * @typeParam FlattenedSchema - resolved schema type (TODO: add detail/example/link to type)
+ */
+export type InjectImplicitModelFields<FlattenedSchema, IdentifierMeta> = {
+    [ModelName in keyof FlattenedSchema]: InjectDefaultFieldsForModel<FlattenedSchema[ModelName], ModelName extends keyof IdentifierMeta ? IdentifierMeta[ModelName] : object>;
+};
+export {};

package/lib-esm/src/MappedTypes/ImplicitFieldInjector.js

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

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

@@ -0,0 +1,20 @@
+import { type UnionToIntersection, type ExcludeEmpty } from '@aws-amplify/data-schema-types';
+import type { ModelType } from '../ModelType';
+import type { ModelRelationalFieldParamShape } from '../ModelRelationalField';
+export type ModelIdentifier<T> = {
+    [Property in keyof T]: T[Property] extends ModelType<infer R, any> ? R['identifier'] extends any[] ? {
+        identifier: R['identifier'][number];
+    } : never : never;
+};
+export type RelationalMetadata<ResolvedSchema, ResolvedFields extends Record<string, unknown>, IdentifierMeta extends Record<string, any>> = UnionToIntersection<ExcludeEmpty<{
+    [ModelName in keyof ResolvedSchema]: {
+        [Field in keyof ResolvedSchema[ModelName] as ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasMany' ? ResolvedSchema[ModelName][Field]['relatedModel'] : ResolvedSchema[ModelName][Field]['relationshipType'] extends 'hasOne' | 'belongsTo' ? ModelName : ResolvedSchema[ModelName][Field]['relationshipType'] extends 'manyToMany' ? ResolvedSchema[ModelName][Field]['relationName'] extends string ? ResolvedSchema[ModelName][Field]['relationName'] : never : never : never]: ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field] extends ModelRelationalFieldParamShape ? ResolvedSchema[ModelName][Field]['relationshipType'] extends 'manyToMany' | 'hasMany' ? {
+            relationalInputFields: Partial<Record<`${Uncapitalize<ModelName & string>}`, NormalizeInputFields<ResolvedFields[ModelName & string], ExtractModelIdentifier<ModelName, IdentifierMeta>>>>;
+        } : {
+            relationalInputFields: Partial<Record<Field, NormalizeInputFields<ResolvedFields[ResolvedSchema[ModelName][Field]['relatedModel']], ExtractModelIdentifier<`${Capitalize<Field & string>}`, IdentifierMeta>>>>;
+        } : never : never;
+    };
+}[keyof ResolvedSchema]>>;
+type ExtractModelIdentifier<ModelName, IdentifierMeta> = ModelName extends keyof IdentifierMeta ? IdentifierMeta[ModelName] : never;
+type NormalizeInputFields<ModelFields, IdentifierMeta extends Record<string, any>> = Partial<Omit<ModelFields, IdentifierMeta['identifier']>> & Required<Pick<ModelFields, IdentifierMeta['identifier']>>;
+export {};

package/lib-esm/src/MappedTypes/ModelMetadata.js

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