@aws-amplify/data-schema 1.2.8 → 1.3.0

package/src/ClientSchema/utilities/ResolveField.ts

@@ -0,0 +1,79 @@
+import { BaseModelField } from '../../ModelField';
+import {
+  ModelRelationalField,
+  ModelRelationalFieldParamShape,
+} from '../../ModelRelationalField';
+import { EnumType } from '../../EnumType';
+import { CustomType } from '../../CustomType';
+import { RefType, RefTypeParamShape } from '../../RefType';
+import { ResolveRef } from './ResolveRef';
+import { LazyLoader } from '../../runtime';
+
+/**
+ * Takes a `ReturnType<typeof a.model()>` and turns it into a client-consumable type. Fields
+ * definitions (e.g., `a.string()`) are turned into the client facing types (e.g., `string`),
+ * `a.ref()` fields will be resolved, and relationships (e.g., `a.belongsTo()`) will be
+ * turned into `LazyLoader` fields (e.g., `post.comments({...})`).
+ *
+ * The first type parameter (`Bag`) should always just be the top-level `ClientSchema` that
+ * references and related model definitions can be resolved against.
+ */
+export type ResolveFields<Bag extends Record<string, any>, T> = ShallowPretty<
+  {
+    [K in keyof T as IsRequired<T[K]> extends true
+      ? K
+      : never]: ResolveIndividualField<Bag, T[K]>;
+  } & {
+    [K in keyof T as IsRequired<T[K]> extends true
+      ? never
+      : K]+?: ResolveIndividualField<Bag, T[K]>;
+  }
+>;
+
+// TODO: Remove ShallowPretty from this layer of resolution. Re-incorporate prettification
+// down the line *as-needed*. Performing this *here* is somehow essential to getting 2 unit
+// tests to pass, but hurts performance significantly. E.g., p50/operations/p50-prod-CRUDL.bench.ts
+// goes from `783705` to `1046408`.
+type ShallowPretty<T> = {
+  [K in keyof T]: T[K];
+};
+
+export type ResolveIndividualField<Bag extends Record<string, any>, T> =
+  T extends BaseModelField<infer FieldShape>
+    ? FieldShape
+    : T extends RefType<infer RefShape, any, any>
+      ? ResolveRef<RefShape, Bag>
+      : T extends ModelRelationalField<infer RelationshipShape, any, any, any>
+        ? ResolveRelationship<Bag, RelationshipShape>
+        : T extends CustomType<infer CT>
+          ? ResolveFields<Bag, CT['fields']> | null
+          : T extends EnumType<infer values>
+            ? values[number] | null
+            : never;
+
+type ResolveRelationship<
+  Bag extends Record<string, any>,
+  RelationshipShape extends ModelRelationalFieldParamShape,
+> = LazyLoader<
+  RelationshipShape['valueRequired'] extends true
+    ? Bag[RelationshipShape['relatedModel']]['type']
+    : Bag[RelationshipShape['relatedModel']]['type'] | null,
+  RelationshipShape['array']
+>;
+
+type IsRequired<T> =
+  T extends BaseModelField<infer FieldShape>
+    ? null extends FieldShape
+      ? false
+      : true
+    : T extends RefType<infer RefShape, any, any>
+      ? IsRefRequired<RefShape>
+      : T extends ModelRelationalField<any, any, any, any>
+        ? true
+        : T extends CustomType<any> | EnumType<any>
+          ? false
+          : never;
+
+type IsRefRequired<T extends RefTypeParamShape> = T['array'] extends true
+  ? T['arrayRequired']
+  : T['valueRequired'];

package/src/ClientSchema/utilities/ResolveRef.ts

@@ -0,0 +1,38 @@
+import type { RefTypeParamShape } from '../../RefType';
+
+/**
+ * Dereferences an `a.ref()` against a given "bag" of independently resolved types.
+ *
+ * This util will examine the ref for requiredness and array-ness and wrap/augment
+ * to referred-to type accordingly.
+ */
+export type ResolveRef<
+  RefShape extends RefTypeParamShape,
+  RefBag extends Record<string, { __entityType: string; type: unknown }>,
+> = ResolveRefValueArrayTraits<
+  RefShape,
+  ApplyRequiredness<
+    RefShape['link'] extends keyof RefBag
+      ? RefBag[RefShape['link']]['type']
+      : never,
+    RefShape['valueRequired']
+  >
+>;
+
+type ApplyRequiredness<
+  Value,
+  MakeRequired extends boolean,
+> = MakeRequired extends true ? Exclude<Value, null> : Value | null | undefined;
+
+/**
+ * Converts the resolved RefType Value type into Array<> according to the
+ * `array` and `arrayRequired` properties of the RefType
+ */
+type ResolveRefValueArrayTraits<
+  Ref extends RefTypeParamShape,
+  Value,
+> = Ref['array'] extends false
+  ? Value
+  : Ref['arrayRequired'] extends true
+    ? Array<Value>
+    : Array<Value> | null | undefined;

package/src/ClientSchema/utilities/SchemaMetadata.ts

@@ -0,0 +1,11 @@
+import { ImpliedAuthFields } from '../../Authorization';
+import { BaseSchema } from '../../ModelSchema';
+
+export interface SchemaMetadata<Schema extends BaseSchema<any, any>> {
+  authFields: AuthFields<Schema>;
+}
+
+type AuthFields<Schema extends Record<string, any>> =
+  Schema['data']['authorization'][number] extends never
+    ? object
+    : ImpliedAuthFields<Schema['data']['authorization'][number]>;

package/src/ClientSchema/utilities/index.ts

@@ -0,0 +1,4 @@
+export * from './ExtractNestedTypes';
+export * from './ResolveField';
+export * from './ResolveRef';
+export * from './SchemaMetadata';

package/src/MappedTypes/ImplicitFieldInjector.ts

@@ -1,4 +1,4 @@
-import type { PrimaryIndexIrShape } from '../runtime/';
+import type { PrimaryIndexIrShape } from '../util';
 
 type DefaultIdentifierFields = {
   // implicit `id` is readonly because it's managed by the resolver; explicit `id` is writable

package/src/MappedTypes/ModelMetadata.ts

@@ -2,7 +2,8 @@ import {
   type UnionToIntersection,
   type ExcludeEmpty,
 } from '@aws-amplify/data-schema-types';
-import { __modelMeta__, type PrimaryIndexIrShape } from '../runtime/';
+import { __modelMeta__ } from '../runtime/';
+import type { PrimaryIndexIrShape } from '../util';
 import type { ModelType } from '../ModelType';
 import type { ModelRelationalFieldParamShape } from '../ModelRelationalField';
 

package/src/MappedTypes/ResolveFieldProperties.ts

@@ -10,7 +10,7 @@ import type {
   ModelRelationalField,
   ModelRelationalFieldParamShape,
 } from '../ModelRelationalField';
-import type { PrimaryIndexIrShape } from '../runtime/';
+import type { PrimaryIndexIrShape } from '../util/';
 
 import type { ResolveSchema, SchemaTypes } from './ResolveSchema';
 import type { InjectImplicitModelFields } from './ImplicitFieldInjector';

package/src/ModelSchema.ts

@@ -31,6 +31,11 @@ import {
   ModelRelationalFieldParamShape,
 } from './ModelRelationalField';
 
+export { ModelType } from './ModelType';
+export { EnumType } from './EnumType';
+export { CustomType } from './CustomType';
+export { CustomOperation } from './CustomOperation';
+
 export const rdsSchemaBrandName = 'RDSSchema';
 export const rdsSchemaBrand = brand(rdsSchemaBrandName);
 export type RDSSchemaBrand = Brand<typeof rdsSchemaBrandName>;
@@ -51,10 +56,11 @@ type AddToSchemaContents = Record<string, AddToSchemaContent>;
 
 type NonEmpty<T> = keyof T extends never ? never : T;
 
-type ModelSchemaContents = Record<string, SchemaContent>;
+export type ModelSchemaContents = Record<string, SchemaContent>;
+
 type InternalSchemaModels = Record<
   string,
-  InternalModel | EnumType<any> | CustomType<any> | InternalCustom
+  InternalModel | EnumType | CustomType<any> | InternalCustom
 >;
 
 export type ModelSchemaParamShape = {
@@ -117,6 +123,10 @@ type RDSModelSchemaFunctions =
   | 'renameModelFields'
   | 'renameModels';
 
+type OmitFromEach<Models, Modifier extends string> = {
+  [ModelName in keyof Models]: Omit<Models[ModelName], Modifier>;
+};
+
 export type RDSModelSchema<
   T extends RDSModelSchemaParamShape,
   UsedMethods extends RDSModelSchemaFunctions = never,
@@ -173,7 +183,7 @@ export type RDSModelSchema<
     >;
     setAuthorization: (
       callback: (
-        models: BaseSchema<T, true>['models'],
+        models: OmitFromEach<BaseSchema<T, true>['models'], 'secondaryIndexes'>,
         schema: RDSModelSchema<T, UsedMethods | 'setAuthorization'>,
       ) => void,
     ) => RDSModelSchema<T>;
@@ -182,7 +192,12 @@ export type RDSModelSchema<
         Partial<Record<keyof T['types'], RelationshipTemplate>>
       >,
     >(
-      callback: (models: BaseSchema<T, true>['models']) => Relationships,
+      callback: (
+        models: OmitFromEach<
+          BaseSchema<T, true>['models'],
+          'authorization' | 'fields' | 'secondaryIndexes'
+        >,
+      ) => Relationships,
     ) => RDSModelSchema<
       UnionToIntersection<Relationships[number]> extends infer RelationshipsDefs
         ? RelationshipsDefs extends Record<string, RelationshipTemplate>

package/src/ModelType.ts

@@ -1,6 +1,9 @@
 import type { SetTypeSubArg } from '@aws-amplify/data-schema-types';
-import type { PrimaryIndexIrShape, SecondaryIndexIrShape } from './runtime';
-import { brand } from './util';
+import {
+  type PrimaryIndexIrShape,
+  type SecondaryIndexIrShape,
+  brand,
+} from './util';
 import type { InternalField, BaseModelField } from './ModelField';
 import type {
   ModelRelationalField,
@@ -352,6 +355,12 @@ export const isSchemaModelType = (
   );
 };
 
+export type ModelDefaultIdentifier = {
+  pk: { readonly id: string };
+  sk: never;
+  compositeSk: never;
+};
+
 /**
  * A data model that creates a matching Amazon DynamoDB table and provides create, read (list and get), update,
  * delete, and subscription APIs.
@@ -363,7 +372,7 @@ export function model<T extends ModelFields>(
   fields: T,
 ): ModelType<{
   fields: T;
-  identifier: { pk: { id: string }; sk: never; compositeSk: never };
+  identifier: ModelDefaultIdentifier;
   secondaryIndexes: [];
   authorization: [];
 }> {