electrodb 1.9.0 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrodb",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "A library to more easily create and interact with multiple entities and heretical relationships in dynamodb",
   "main": "index.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "test-ts": "mocha -r ts-node/register ./test/**.spec.ts",
     "test-all": "mocha ./test/**.spec.js",
     "test-all-local": "LOCAL_DYNAMO_ENDPOINT=http://localhost:8000 node ./test/init.js && LOCAL_DYNAMO_ENDPOINT=http://localhost:8000 mocha ./test/**.spec.js && npm run test-types && LOCAL_DYNAMO_ENDPOINT=http://localhost:8000 npm run test-ts",
-    "test-types": "node ./node_modules/tsd/dist/cli.js",
+    "test-types": "tsd",
     "coverage": "nyc npm run test-all && nyc report --reporter=text-lcov | coveralls",
     "coverage-coveralls-local": "nyc npm run test-all-local && nyc report --reporter=text-lcov | coveralls",
     "coverage-html-local": "nyc npm run test-all-local && nyc report --reporter=html",
@@ -43,9 +43,9 @@
     "moment": "2.24.0",
     "nyc": "^15.1.0",
     "source-map-support": "^0.5.19",
-    "ts-node": "^9.0.0",
-    "tsd": "^0.14.0",
-    "typescript": "^4.2.4",
+    "ts-node": "^10.8.1",
+    "tsd": "^0.21.0",
+    "typescript": "^4.7.4",
     "uuid": "7.0.1"
   },
   "keywords": [
@@ -61,7 +61,7 @@
     "directory": "test"
   },
   "dependencies": {
-    "jsonschema": "1.2.7",
-    "@aws-sdk/lib-dynamodb": "^3.54.1"
+    "@aws-sdk/lib-dynamodb": "^3.54.1",
+    "jsonschema": "1.2.7"
   }
 }

package/src/entity.d.ts

@@ -0,0 +1,94 @@
+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';
+
+export 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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,243 @@
+import { Entity } from '../entity';
+import {
+    GoRecord,
+    ParamRecord,
+    PageRecord,
+} from './options';
+import {
+  EntityCollections,
+  ItemAttribute,
+  ResponseItem,
+  Schema,
+  TableIndexCompositeAttributes,
+} from './schema';
+import {
+  WhereAttributeSymbol
+} from './where';
+
+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];
+
+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];
+
+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];
+}
+
+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]
+}
+
+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;
+}
+
+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;
+
+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;
+
+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>>;
+}
+
+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]]
+}
+
+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]]
+}
+
+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
+  }
+}
+
+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
+  }
+}
+
+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]
+type SpreadProperties<L, R, K extends keyof L & keyof R> =
+{ [P in K]: L[P] | Exclude<R[P], undefined> };
+
+type Id<T> = {[K in keyof T]: T[K]} // see note at bottom*
+
+// Type of { ...L, ...R }
+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>
+>;
+
+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

@@ -0,0 +1,47 @@
+type ElectroDBMethodTypes = "put" | "get" | "query" | "scan" | "update" | "delete" | "remove" | "patch" | "create" | "batchGet" | "batchWrite";
+
+interface ElectroQueryEvent<P extends any = any> {
+    type: 'query';
+    method: ElectroDBMethodTypes;
+    config: any;
+    params: P;
+}
+
+interface ElectroResultsEvent<R extends any = any> {
+    type: 'results';
+    method: ElectroDBMethodTypes;
+    config: any;
+    results: R;
+    success: boolean;
+}
+
+type ElectroEvent = 
+    ElectroQueryEvent
+    | ElectroResultsEvent;
+
+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

@@ -0,0 +1,67 @@
+import { Entity } from '../entity';
+import { ResponseItem, PutItem, AddItem, SubtractItem, AppendItem, RemoveItem, DeleteItem, Item } from './schema';
+import { Service } from '../service';
+import { CollectionAssociations } from './collections';
+
+export { WhereAttributeSymbol } from './where';
+export { Schema } from './schema';
+
+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