@aws-amplify/data-schema 1.2.8 → 1.3.0

package/src/runtime/internals/generateCustomOperationsProperty.ts

@@ -37,7 +37,7 @@ export function generateCustomOperationsProperty<
   config: GraphQLProviderConfig['GraphQL'],
   operationsType: OpType,
   getInternals: ClientInternalsGetter,
-): OpType extends 'queries' ? CustomQueries<T> : CustomMutations<T> {
+): CustomOpsProperty<T, OpType> {
   // some bundlers end up with `Amplify.configure` being called *after* generate client.
   // if that occurs, we need to *not error* while we wait. handling for late configuration
   // occurs in `generateClient()`. we do not need to subscribe to Hub events here.
@@ -73,7 +73,7 @@ export function generateCustomOperationsProperty<
     );
   }
 
-  return ops;
+  return ops as CustomOpsProperty<T, OpType>;
 }
 
 export function generateCustomMutationsProperty<T extends Record<any, any>>(

package/src/runtime/internals/utils/clientProperties/generateEnumsProperty.ts

@@ -14,7 +14,7 @@ export const generateEnumsProperty = <T extends Record<any, any> = never>(
     graphqlConfig.modelIntrospection;
 
   if (!modelIntrospection) {
-    return {} as EnumTypes<never>;
+    return {} as any;
   }
 
   const enums: Record<

package/src/util/Filters.ts

@@ -0,0 +1,102 @@
+/**
+ * Not actually sure if/how customer can pass this through as variables yet.
+ * Leaving it out for now:
+ *
+ * attributeType: "binary" | "binarySet" | "bool" | "list" | "map" | "number" | "numberSet" | "string" | "stringSet" | "_null"
+ */
+
+/**
+ * Filters options that can be used on string-like fields.
+ */
+
+export type StringFilter<T extends string = string> = {
+  attributeExists?: boolean;
+  beginsWith?: string;
+  between?: [string, string];
+  contains?: string;
+  eq?: T;
+  ge?: string;
+  gt?: string;
+  le?: string;
+  lt?: string;
+  ne?: T;
+  notContains?: string;
+  size?: SizeFilter;
+};
+
+export type NumericFilter = {
+  attributeExists?: boolean;
+  between?: [number, number];
+  eq?: number;
+  ge?: number;
+  gt?: number;
+  le?: number;
+  lt?: number;
+  ne?: number;
+};
+
+/**
+ * Filter options that can be used on fields where size checks are supported.
+ */
+export type SizeFilter = {
+  between?: [number, number];
+  eq?: number;
+  ge?: number;
+  gt?: number;
+  le?: number;
+  lt?: number;
+  ne?: number;
+};
+
+export type BooleanFilters = {
+  attributeExists?: boolean;
+  eq?: boolean;
+  ne?: boolean;
+};
+
+/**
+ * A composite SK (in an identifier or secondaryIndex) resolves to this type for
+ * list queries and index queries
+ * 
+ * @example
+ * Given
+ * ```ts
+ * MyModel: a
+  .model({
+    pk: a.string().required(),
+    sk1: a.string().required(),
+    sk2: a.integer().required(),
+  })
+  .identifier(['pk', 'sk1', 'sk2']),
+ * ``` 
+ * Expected list options: 
+ * ```ts
+ * {
+ *   pk?: string
+ *   sk1Sk2?: ModelPrimaryCompositeKeyConditionInput
+ * }
+ * ```
+ * Where ModelPrimaryCompositeKeyConditionInput resolves to:
+ * ```ts
+ * {
+ *   eq: {sk1: string; sk2: number};
+ *   le: {sk1: string; sk2: number};
+ *   lt: {sk1: string; sk2: number};
+ *   ge: {sk1: string; sk2: number};
+ *   gt: {sk1: string; sk2: number};
+ *   between: [ {sk1: string; sk2: number} ];
+ *   beginsWith: {sk1: string; sk2: number};
+ * }
+ * ```
+ * */
+export type ModelPrimaryCompositeKeyInput<
+  SkIr extends Record<string, string | number>,
+> = {
+  eq?: SkIr;
+  le?: SkIr;
+  lt?: SkIr;
+  ge?: SkIr;
+  gt?: SkIr;
+  between?: [SkIr];
+  beginsWith?: SkIr;
+};

package/src/util/IndexShapes.ts

@@ -0,0 +1,10 @@
+export interface PrimaryIndexIrShape {
+  pk: { [key: string]: string | number };
+  sk: { [key: string]: string | number } | never;
+  compositeSk: never | string;
+}
+
+export interface SecondaryIndexIrShape extends PrimaryIndexIrShape {
+  defaultQueryFieldSuffix: string;
+  queryField: string;
+}

package/src/util/Select.ts

@@ -0,0 +1,3 @@
+export type Select<T, M> = {
+  [K in keyof T as T[K] extends M ? K : never]: T[K] extends M ? T[K] : never;
+};

package/src/util/index.ts

@@ -1,3 +1,6 @@
 export { Brand, brand, getBrand } from './Brand';
 export { IndexLimitUnion } from './IndexLimit';
 export { SpreadTuple } from './SpreadTuple';
+export { Select } from './Select';
+export type * from './Filters';
+export type * from './IndexShapes';

package/dist/cjs/ClientSchema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClientSchema.js","sources":["../../src/ClientSchema.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/cjs/MappedTypes/CustomOperations.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CustomOperations.js","sources":["../../../src/MappedTypes/CustomOperations.ts"],"sourcesContent":["\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n"],"names":[],"mappings":";;AACA,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;;"}

package/dist/esm/ClientSchema.d.ts

@@ -1,51 +0,0 @@
-import type { __modelMeta__ } from './runtime/client';
-import type { GenericModelSchema, RDSModelSchema } from './ModelSchema';
-import type { ResolveSchema, SchemaTypes } from './MappedTypes/ResolveSchema';
-import type { ResolveFieldProperties, ResolveStaticFieldProperties } from './MappedTypes/ResolveFieldProperties';
-import type { ModelIdentifier, ModelSecondaryIndexes, RelationalMetadata } from './MappedTypes/ModelMetadata';
-import type { ExtractNonModelTypes, NonModelTypesShape } from './MappedTypes/ExtractNonModelTypes';
-import type { ResolveCustomOperations, CustomOperationHandlerTypes } from './MappedTypes/CustomOperations';
-import type { CombinedModelSchema, CombinedSchemaIndexesUnion } from './CombineSchema';
-import type { 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
- *
- * @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 - Resolve the schema types used by other generics
- * @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>, ResolvedFields extends Record<string, unknown> = Schema extends RDSModelSchema<any, any> ? ResolveStaticFieldProperties<Schema, NonModelTypes, object> : ResolveFieldProperties<Schema, NonModelTypes>, 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']> & {
-    [K in keyof ResolvedFields]: {
-        type: ResolvedFields[K];
-    };
-} & {
-    [__modelMeta__]: IdentifierMeta & 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 ? Omit<ClientSchemas[I], typeof __modelMeta__> : never;
-}> & {
-    [__modelMeta__]: SpreadTuple<{
-        [I in keyof ClientSchemas]: I extends CombinedSchemaIndexesUnion ? ClientSchemas[I][typeof __modelMeta__] : never;
-    }>;
-};
-export {};

package/dist/esm/ClientSchema.mjs

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=ClientSchema.mjs.map

package/dist/esm/ClientSchema.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ClientSchema.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/esm/MappedTypes/CustomOperations.d.ts

@@ -1,125 +0,0 @@
-import type { GenericModelSchema } from '../ModelSchema';
-import type { NonModelTypesShape } from './ExtractNonModelTypes';
-import type { CustomOperation, CustomOperationParamShape } from '../CustomOperation';
-import type { BaseModelField } from '../ModelField';
-import type { RefType, RefTypeParamShape } from '../RefType';
-import type { ResolveFieldRequirements, ResolveRefsOfCustomType, ResolveRefValueArrayTraits } from './ResolveFieldProperties';
-import type { AppSyncResolverHandler } from 'aws-lambda';
-import type { CustomType } from '../CustomType';
-import type { FieldTypesOfCustomType } from './ResolveSchema';
-/**
- * Creates meta types for custom operations from a schema.
- */
-export type ResolveCustomOperations<Schema extends GenericModelSchema<any>, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, CustomOperations extends Record<string, CustomOperationParamShape> = CustomOpShapes<Schema>> = {
-    customOperations: {
-        [OpName in keyof CustomOperations]: {
-            arguments: CustomOpArguments<CustomOperations[OpName]>;
-            returnType: CustomOpReturnType<CustomOperations[OpName], FullyResolvedSchema, NonModelTypes, CustomOperations>;
-            typeName: CustomOperations[OpName]['typeName'];
-            authorization: CustomOperations[OpName]['authorization'];
-        };
-    };
-};
-/**
- * Filtered, mapped list of custom operations shapes from a schema.
- */
-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;
-};
-/**
- * Digs out custom operation arguments, mapped to the intended graphql types.
- */
-export type CustomOpArguments<Shape extends CustomOperationParamShape> = Shape['arguments'] extends null ? never : ResolveFieldRequirements<{
-    [FieldName in keyof Shape['arguments']]: Shape['arguments'][FieldName] extends BaseModelField<infer R> ? R : never;
-}>;
-/**
- * Computes the return type from the `returnType` of a custom operation shape.
- *
- * This entails dereferencing refs and inferring graphql types from field-type defs.
- */
-export type CustomOpReturnType<Shape extends CustomOperationParamShape, FullyResolvedSchema extends Record<string, unknown>, NonModelTypes extends NonModelTypesShape, CustomOperations extends Record<string, CustomOperationParamShape>> = Shape['returnType'] extends RefType<infer RefShape, any, any> ? RefShape['link'] extends keyof CustomOperations ? CustomOpReturnType<CustomOperations[RefShape['link']], FullyResolvedSchema, NonModelTypes, CustomOperations> : ResolveRef<RefShape, FullyResolvedSchema, NonModelTypes, CustomOperations> : Shape['returnType'] extends BaseModelField<infer R> ? R : Shape['returnType'] extends CustomType<infer R> ? ResolveFieldRequirements<FieldTypesOfCustomType<{
-    thisCustomType: R['fields'];
-}>['thisCustomType']> | null : never;
-/**
- * `a.ref()` resolution specific to custom operations, for which `a.ref()`
- * can refer to a model, custom type, or enum.
- *
- * This utility is a duplication of ResolveRef (src/MappedTypes/ResolveFieldProperties.ts)
- * 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, CustomOperations extends Record<string, CustomOperationParamShape>, 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]> : Link extends keyof CustomOperations ? CustomOpReturnType<CustomOperations[Link], FullyResolvedSchema, NonModelTypes, CustomOperations> : 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 IndividualCustomHandlerTypes<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;
-     * }
-     * ```
-     */
-    args: 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;
-     * }
-     * ```
-     */
-    returnType: 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]: IndividualCustomHandlerTypes<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/dist/esm/MappedTypes/CustomOperations.mjs

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=CustomOperations.mjs.map

package/dist/esm/MappedTypes/CustomOperations.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"CustomOperations.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/src/ClientSchema.ts

@@ -1,121 +0,0 @@
-import type { __modelMeta__ } from './runtime/client';
-import type { GenericModelSchema, RDSModelSchema } from './ModelSchema';
-
-// MappedTypes
-import type { ResolveSchema, SchemaTypes } from './MappedTypes/ResolveSchema';
-import type {
-  ResolveFieldProperties,
-  ResolveStaticFieldProperties,
-} from './MappedTypes/ResolveFieldProperties';
-import type {
-  ModelIdentifier,
-  ModelSecondaryIndexes,
-  RelationalMetadata,
-} from './MappedTypes/ModelMetadata';
-import type {
-  ExtractNonModelTypes,
-  NonModelTypesShape,
-} from './MappedTypes/ExtractNonModelTypes';
-import type {
-  ResolveCustomOperations,
-  CustomOperationHandlerTypes,
-} from './MappedTypes/CustomOperations';
-import type {
-  CombinedModelSchema,
-  CombinedSchemaIndexesUnion,
-} from './CombineSchema';
-import type { 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
- *
- * @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 - Resolve the schema types used by other generics
- * @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>,
-  ResolvedFields extends Record<
-    string,
-    unknown
-  > = Schema extends RDSModelSchema<any, any>
-    ? ResolveStaticFieldProperties<Schema, NonModelTypes, object>
-    : ResolveFieldProperties<Schema, NonModelTypes>,
-  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']
-> & {
-  [K in keyof ResolvedFields]: {
-    type: ResolvedFields[K];
-  };
-} & {
-  [__modelMeta__]: IdentifierMeta &
-    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
-    ? Omit<ClientSchemas[I], typeof __modelMeta__>
-    : never;
-}> & {
-  [__modelMeta__]: SpreadTuple<{
-    [I in keyof ClientSchemas]: I extends CombinedSchemaIndexesUnion
-      ? ClientSchemas[I][typeof __modelMeta__]
-      : never;
-  }>;
-};