electrodb 1.10.1 → 1.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "1.10.1",
+  "version": "1.10.2",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {

package/src/entity.d.ts

@@ -1,94 +0,0 @@
-import {
-  ParseOptions
-} from './types/options';
-import {
-  TableIndexCompositeAttributes,
-  AllTableIndexCompositeAttributes, 
-  ResponseItem, 
-  Item, 
-  Schema, 
-  SetItem, 
-  AddItem, 
-  SubtractItem, 
-  AppendItem, 
-  DeleteItem,
-  RemoveItem,
-  PutItem,
-} from './types/schema';
-
-import {
-  Queries,
-  SetRecord,
-  RemoveRecord,
-  DataUpdateMethodRecord,
-  RecordsActionOptions,
-  SingleRecordOperationOptions,
-  BulkRecordOperationOptions,
-  DeleteRecordOperationOptions,
-  PutRecordOperationOptions,
-  ParseSingleInput,
-  ParseMultiInput
-} from './types/model';
-
-import { ElectroEventListener } from './types/events';
-import { DocumentClient } from './types/client';
-
-type Resolve<T> = T extends Function | string | number | boolean
-    ? T : {[Key in keyof T]: Resolve<T[Key]>}
-
-export type EntityConfiguration = {
-  table?: string;
-  client?: DocumentClient;
-  listeners?: Array<ElectroEventListener>;
-  logger?: ElectroEventListener;
-};
-
-export class Entity<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> {
-  readonly schema: S;
-  private config?: EntityConfiguration; 
-  constructor(schema: S, config?: EntityConfiguration);
-
-  get(key: AllTableIndexCompositeAttributes<A,F,C,S>): SingleRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S> | null>;
-  get(key: AllTableIndexCompositeAttributes<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, [Array<Resolve<ResponseItem<A,F,C,S>>>, Array<Resolve<AllTableIndexCompositeAttributes<A,F,C,S>>>], [Array<Resolve<ResponseItem<A,F,C,S>> | null>, Array<Resolve<AllTableIndexCompositeAttributes<A,F,C,S>>>]>;
-
-  delete(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
-  delete(key: AllTableIndexCompositeAttributes<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, AllTableIndexCompositeAttributes<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>[]>;
-
-  put(record: PutItem<A,F,C,S>): PutRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>;
-  put(record: PutItem<A,F,C,S>[]): BulkRecordOperationOptions<A,F,C,S, AllTableIndexCompositeAttributes<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>[]>;
-
-  remove(key: AllTableIndexCompositeAttributes<A,F,C,S>): DeleteRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>
-  update(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
-      set: SetRecord<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      remove: RemoveRecord<A,F,C,S, RemoveItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      add: SetRecord<A,F,C,S, AddItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-  };
-
-  patch(key: AllTableIndexCompositeAttributes<A,F,C,S>): {
-      set: SetRecord<A,F,C,S, SetItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      remove: RemoveRecord<A,F,C,S, RemoveItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      add: SetRecord<A,F,C,S, AddItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-      data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>, TableIndexCompositeAttributes<A,F,C,S>, ResponseItem<A,F,C,S>>;
-  };
-  
-  create(record: PutItem<A,F,C,S>): PutRecordOperationOptions<A,F,C,S, ResponseItem<A,F,C,S>>
-
-  find(record: Partial<Item<A,F,C,S,S["attributes"]>>): RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>>;
-
-  match(record: Partial<Item<A,F,C,S,S["attributes"]>>): RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S>>;
-
-  scan: RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], TableIndexCompositeAttributes<A,F,C,S>>;
-  query: Queries<A,F,C,S>;
-  
-  parse(item: ParseSingleInput, options?: ParseOptions): ResponseItem<A,F,C,S> | null;
-  parse(item: ParseMultiInput, options?: ParseOptions): ResponseItem<A,F,C,S>[];
-  setIdentifier(type: "entity" | "version", value: string): void;
-  client: any;
-}

package/src/entity.test-d.ts

@@ -1,110 +0,0 @@
-import { Entity } from './entity';
-
-const entityWithSK = new Entity({
-  model: {
-      entity: "abc",
-      service: "myservice",
-      version: "myversion"
-  },
-  attributes: {
-      attr1: {
-          type: "string",
-          default: "abc",
-          get: (val) => val + 123,
-          set: (val) => (val ?? "") + 456,
-          validate: (val) => !!val,
-      },
-      attr2: {
-          type: "string",
-          // default: () => "sfg",
-          // required: false,
-          validate: (val) => val.length > 0
-      },
-      attr3: {
-          type: ["123", "def", "ghi"] as const,
-          default: "def"
-      },
-      attr4: {
-          type: ["abc", "ghi"] as const,
-          required: true
-      },
-      attr5: {
-          type: "string"
-      },
-      attr6: {
-          type: "number",
-          default: () => 100,
-          get: (val) => val + 5,
-          set: (val) => (val ?? 0) + 5,
-          validate: (val) => true,
-      },
-      attr7: {
-          type: "any",
-          default: () => false,
-          get: (val) => ({key: "value"}),
-          set: (val) => (val ?? 0) + 5,
-          validate: (val) => true,
-      },
-      attr8: {
-          type: "boolean",
-          required: true,
-          get: (val) => !!val,
-          set: (val) => !!val,
-          validate: (val) => !!val,
-      },
-      attr9: {
-          type: "number"
-      },
-      attr10: {
-          type: "boolean"
-      },
-      attr11: {
-        type: 'list',
-        items: {
-            type: 'string'
-        }
-      }
-  },
-  indexes: {
-      myIndex: {
-          collection: "mycollection2",
-          pk: {
-              field: "pk",
-              composite: ["attr1"]
-          },
-          sk: {
-              field: "sk",
-              composite: ["attr2"]
-          }
-      },
-      myIndex2: {
-          collection: "mycollection1",
-          index: "gsi1",
-          pk: {
-              field: "gsipk1",
-              composite: ["attr6", "attr9"]
-          },
-          sk: {
-              field: "gsisk1",
-              composite: ["attr4", "attr5"]
-          }
-      },
-      myIndex3: {
-          collection: "mycollection",
-          index: "gsi2",
-          pk: {
-              field: "gsipk2",
-              composite: ["attr5"]
-          },
-          sk: {
-              field: "gsisk2",
-              composite: ["attr4", "attr3", "attr9"]
-          }
-      }
-  }
-});
-
-entityWithSK.update({
-    attr1: 'abc', 
-    attr2: 'def'
-}).append({})

package/src/service.d.ts

@@ -1,17 +0,0 @@
-import { Entity } from './entity';
-import { DocumentClient } from './types/client';
-import { ElectroEventListener } from './types/events';
-import { CollectionQueries, CollectionAssociations } from './types/collections';
-
-export type ServiceConfiguration = {
-  table?: string;
-  client?: DocumentClient;
-  listeners?: Array<ElectroEventListener>;
-  logger?: ElectroEventListener;
-};
-
-export class Service<E extends {[name: string]: Entity<any, any, any, any>}> {
-  entities: E;
-  collections: CollectionQueries<E, CollectionAssociations<E>>
-  constructor(entities: E, config?: ServiceConfiguration);
-}

package/src/types/client.ts

@@ -1,15 +0,0 @@
-export type DocumentClientMethod = (parameters: any) => {promise: () => Promise<any>};
-
-export type DocumentClient = {
-    get: DocumentClientMethod;
-    put: DocumentClientMethod;
-    delete: DocumentClientMethod;
-    update: DocumentClientMethod;
-    batchWrite: DocumentClientMethod;
-    batchGet: DocumentClientMethod;
-    scan: DocumentClientMethod;
-    transactGet: DocumentClientMethod;
-    transactWrite: DocumentClientMethod;
-} | {
-    send: (command: any) => Promise<any>;
-}

package/src/types/collections.ts

@@ -1,243 +0,0 @@
-import { Entity } from '../entity';
-import {
-    GoRecord,
-    ParamRecord,
-    PageRecord,
-} from './options';
-import {
-  EntityCollections,
-  ItemAttribute,
-  ResponseItem,
-  Schema,
-  TableIndexCompositeAttributes,
-} from './schema';
-import {
-  WhereAttributeSymbol
-} from './where';
-
-export type AllCollectionNames<E extends {[name: string]: Entity<any, any, any, any>}> = {
-  [Name in keyof E]:
-  E[Name] extends Entity<infer A, infer F, infer C, infer S>
-      ? {
-          [Collection in keyof EntityCollections<A,F,C,S>]: Collection
-      }[keyof EntityCollections<A,F,C,S>]
-      : never
-}[keyof E];
-
-export type AllEntityAttributeNames<E extends {[name: string]: Entity<any, any, any, any>}> = {
-  [Name in keyof E]: {
-      [A in keyof E[Name]["schema"]["attributes"]]: A
-  }[keyof E[Name]["schema"]["attributes"]]
-}[keyof E];
-
-export type AllEntityAttributes<E extends {[name: string]: Entity<any, any, any, any>}> = {
-  [Attr in AllEntityAttributeNames<E>]: {
-      [Name in keyof E]: Attr extends keyof E[Name]["schema"]["attributes"]
-          ? ItemAttribute<E[Name]["schema"]["attributes"][Attr]>
-          : never
-  }[keyof E];
-};
-
-export type CollectionAssociations<E extends {[name: string]: Entity<any, any, any, any>}> = {
-  [Collection in AllCollectionNames<E>]: {
-      [Name in keyof E]: E[Name] extends Entity<infer A, infer F, infer C, infer S>
-          ? Collection extends keyof EntityCollections<A,F,C,S>
-              ? Name
-              : never
-          : never
-  }[keyof E];
-}
-
-export type CollectionAttributes<E extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<E>> = {
-  [Collection in keyof Collections]: {
-      [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
-          ? EntityName extends Collections[Collection]
-              ? keyof S["attributes"]
-              : never
-          : never
-  }[keyof E]
-}
-
-export interface CollectionWhereOperations {
-  eq: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  ne: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  gt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  lt: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  gte: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  lte: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  between: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T, value2: T) => string;
-  begins: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  exists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-  notExists: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-  contains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  notContains: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  value: <T, A extends WhereAttributeSymbol<T>>(attr: A, value: T) => string;
-  name: <T, A extends WhereAttributeSymbol<T>>(attr: A) => string;
-}
-
-export type CollectionWhereCallback<E extends {[name: string]: Entity<any, any, any, any>}, I extends Partial<AllEntityAttributes<E>>> =
-    <W extends {[A in keyof I]: WhereAttributeSymbol<I[A]>}>(attributes: W, operations: CollectionWhereOperations) => string;
-
-export type CollectionWhereClause<E extends {[name: string]: Entity<any, any, any, any>}, A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Partial<AllEntityAttributes<E>>, T> = (where: CollectionWhereCallback<E, I>) => T;
-
-export interface WhereRecordsActionOptions<E extends {[name: string]: Entity<any, any, any, any>}, A extends string, F extends string, C extends string, S extends Schema<A,F,C>, I extends Partial<AllEntityAttributes<E>>, Items, IndexCompositeAttributes> {
-    go: GoRecord<Items>;
-    params: ParamRecord;
-    page: PageRecord<Items,IndexCompositeAttributes>;
-    where: CollectionWhereClause<E,A,F,C,S,I, WhereRecordsActionOptions<E,A,F,C,S,I,Items,IndexCompositeAttributes>>;
-}
-
-export type CollectionIndexKeys<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-  [Collection in keyof Collections]: {
-      [EntityResultName in Collections[Collection]]:
-          EntityResultName extends keyof Entities
-              ? Entities[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                  ? keyof TableIndexCompositeAttributes<A, F, C, S>
-                  : never
-              : never
-  }[Collections[Collection]]
-}
-
-export type CollectionPageKeys<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-  [Collection in keyof Collections]: {
-      [EntityResultName in Collections[Collection]]:
-          EntityResultName extends keyof Entities
-              ? Entities[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                  ? keyof Parameters<Entities[EntityResultName]["query"][
-                      Collection extends keyof EntityCollections<A,F,C,S>
-                          ? EntityCollections<A,F,C,S>[Collection]
-                          : never
-                  ]>[0]
-                  : never
-              : never
-  }[Collections[Collection]]
-}
-
-export type CollectionIndexAttributes<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-  [Collection in keyof CollectionIndexKeys<Entities, Collections>]: {
-      [key in CollectionIndexKeys<Entities, Collections>[Collection]]:
-          key extends keyof AllEntityAttributes<Entities>
-              ? AllEntityAttributes<Entities>[key]
-              : never
-  }
-}
-
-export type CollectionPageAttributes<Entities extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<Entities>> = {
-  [Collection in keyof CollectionPageKeys<Entities, Collections>]: {
-      [key in CollectionPageKeys<Entities, Collections>[Collection]]:
-          key extends keyof AllEntityAttributes<Entities>
-              ? AllEntityAttributes<Entities>[key]
-              : never
-  }
-}
-
-export type OptionalPropertyNames<T> =
-  { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T];
-
-// Common properties from L and R with undefined in R[K] replaced by type in L[K]
-export type SpreadProperties<L, R, K extends keyof L & keyof R> =
-{ [P in K]: L[P] | Exclude<R[P], undefined> };
-
-export type Id<T> = {[K in keyof T]: T[K]} // see note at bottom*
-
-// Type of { ...L, ...R }
-export type Spread<L, R> = Id<
-// Properties in L that don't exist in R
-& Pick<L, Exclude<keyof L, keyof R>>
-// Properties in R with types that exclude undefined
-& Pick<R, Exclude<keyof R, OptionalPropertyNames<R>>>
-// Properties in R, with types that include undefined, that don't exist in L
-& Pick<R, Exclude<OptionalPropertyNames<R>, keyof L>>
-// Properties in R, with types that include undefined, that exist in L
-& SpreadProperties<L, R, OptionalPropertyNames<R> & keyof L>
->;
-
-export type RequiredProperties<T> = Pick<T, {[K in keyof T]-?: {} extends Pick<T, K> ? never : K }[keyof T]>
-
-export type CollectionQueries<E extends {[name: string]: Entity<any, any, any, any>}, Collections extends CollectionAssociations<E>> = {
-  [Collection in keyof Collections]: {
-      [EntityName in keyof E]:
-          EntityName extends Collections[Collection]
-              ? (params:
-                     RequiredProperties<
-                         Parameters<
-                             E[EntityName]["query"][
-                                 E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
-                                     ? Collection extends keyof EntityCollections<A,F,C,S>
-                                      ? EntityCollections<A,F,C,S>[Collection]
-                                      : never
-                                     : never
-                             ]
-                         >[0]
-                     >) => {
-                  go: GoRecord<{
-                      [EntityResultName in Collections[Collection]]:
-                          EntityResultName extends keyof E
-                              ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                  ? ResponseItem<A,F,C,S>[]
-                                  : never
-                              : never
-                  }>;
-                  params: ParamRecord;
-                  page: {
-                      [EntityResultName in Collections[Collection]]: EntityResultName extends keyof E
-                          ? Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>> extends Partial<AllEntityAttributes<E>>
-                              ?
-                                  PageRecord<
-                                      {
-                                          [EntityResultName in Collections[Collection]]:
-                                          EntityResultName extends keyof E
-                                              ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                                  ? ResponseItem<A,F,C,S>[]
-                                                  : never
-                                              : never
-                                      },
-                                      Partial<
-                                          Spread<
-                                              Collection extends keyof CollectionPageAttributes<E, Collections>
-                                                  ? CollectionPageAttributes<E, Collections>[Collection]
-                                                  : {},
-                                              Collection extends keyof CollectionIndexAttributes<E, Collections>
-                                                  ? CollectionIndexAttributes<E, Collections>[Collection]
-                                                  : {}
-                                          >
-                                      >
-                                  >
-                              : never
-                          : never
-                  }[Collections[Collection]];
-                  where: {
-                      [EntityResultName in Collections[Collection]]: EntityResultName extends keyof E
-                              ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                  ? Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>> extends Partial<AllEntityAttributes<E>>
-                                      ? CollectionWhereClause<E,A,F,C,S,
-                                          Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>>,
-                                          WhereRecordsActionOptions<E,A,F,C,S,
-                                              Pick<AllEntityAttributes<E>, Extract<AllEntityAttributeNames<E>, CollectionAttributes<E,Collections>[Collection]>>,
-                                                  {
-                                                      [EntityResultName in Collections[Collection]]:
-                                                          EntityResultName extends keyof E
-                                                              ? E[EntityResultName] extends Entity<infer A, infer F, infer C, infer S>
-                                                                  ? ResponseItem<A,F,C,S>[]
-                                                                  : never
-                                                              : never
-                                                  },
-                                                  Partial<
-                                                      Spread<
-                                                          Collection extends keyof CollectionPageAttributes<E, Collections>
-                                                              ? CollectionPageAttributes<E, Collections>[Collection]
-                                                              : {},
-                                                          Collection extends keyof CollectionIndexAttributes<E, Collections>
-                                                              ? CollectionIndexAttributes<E, Collections>[Collection]
-                                                              : {}
-                                                          >
-                                                  >
-                                              >>
-                                      : never
-                                  : never
-                              : never
-                  }[Collections[Collection]];
-              }
-              : never
-  }[keyof E];
-}

package/src/types/events.ts

@@ -1,47 +0,0 @@
-export type ElectroDBMethodTypes = "put" | "get" | "query" | "scan" | "update" | "delete" | "remove" | "patch" | "create" | "batchGet" | "batchWrite";
-
-export interface ElectroQueryEvent<P extends any = any> {
-    type: 'query';
-    method: ElectroDBMethodTypes;
-    config: any;
-    params: P;
-}
-
-export interface ElectroResultsEvent<R extends any = any> {
-    type: 'results';
-    method: ElectroDBMethodTypes;
-    config: any;
-    results: R;
-    success: boolean;
-}
-
-export type ElectroEvent =
-    ElectroQueryEvent
-    | ElectroResultsEvent;
-
-export type ElectroEventType = Pick<ElectroEvent, 'type'>;
-
-export type ElectroEventListener = (event: ElectroEvent) => void;
-
-// todo: coming soon, more events!
-// | {
-//     name: "error";
-//     type: "configuration_error" | "invalid_query" | "dynamodb_client";
-//     message: string;
-//     details: ElectroError;
-// } | {
-//     name: "error";
-//     type: "user_defined";
-//     message: string;
-//     details: ElectroValidationError;
-// } | {
-//     name: "warn";
-//     type: "deprecation_warning" | "optimization_suggestion";
-//     message: string;
-//     details: any;
-// } | {
-//     name: "info";
-//     type: "client_updated" | "table_overwritten";
-//     message: string;
-//     details: any;
-// };

package/src/types/index.ts

@@ -1,72 +0,0 @@
-import { Entity } from '../entity';
-import { ResponseItem, PutItem, AddItem, SubtractItem, AppendItem, RemoveItem, DeleteItem, Item } from './schema';
-import { Service } from '../service';
-import { CollectionAssociations } from './collections';
-
-export * from './where';
-export * from './schema';
-export * from './options';
-export * from './client';
-export * from './collections';
-export * from './model';
-export * from './events';
-
-export type EntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? ResponseItem<A, F, C, S>
-        : never;
-
-export type CreateEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? PutItem<A, F, C, S>
-        : never;
-
-export type UpdateEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? Partial<ResponseItem<A,F,C,S>>
-        : never;
-
-export type UpdateAddEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? AddItem<A, F, C, S>
-        : never;
-
-export type UpdateSubtractEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? SubtractItem<A, F, C, S>
-        : never;
-
-export type UpdateAppendEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? AppendItem<A, F, C, S>
-        : never;
-
-export type UpdateRemoveEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? RemoveItem<A, F, C, S>
-        : never;
-
-export type UpdateDeleteEntityItem<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? DeleteItem<A, F, C, S>
-        : never;
-
-export type EntityRecord<E extends Entity<any, any, any, any>> =
-    E extends Entity<infer A, infer F, infer C, infer S>
-        ? Item<A,F,C,S,S["attributes"]>
-        : never;
-
-export type CollectionItem<SERVICE extends Service<any>, COLLECTION extends keyof SERVICE["collections"]> =
-    SERVICE extends Service<infer E>
-        ? Pick<{
-            [EntityName in keyof E]: E[EntityName] extends Entity<infer A, infer F, infer C, infer S>
-            ? COLLECTION extends keyof CollectionAssociations<E>
-                ? EntityName extends CollectionAssociations<E>[COLLECTION]
-                    ? ResponseItem<A,F,C,S>[]
-                    : never
-                : never
-            : never
-        }, COLLECTION extends keyof CollectionAssociations<E>
-            ? CollectionAssociations<E>[COLLECTION]
-            : never>
-        : never