electrodb 1.8.4 → 1.10.1

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';
+
+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

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

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

package/src/types/model.ts

@@ -0,0 +1,132 @@
+import {
+  GoRecord,
+  ParamRecord,
+  QueryOptions,
+  PageRecord,
+  PutQueryOptions,
+  UpdateQueryOptions,
+  UpdateQueryParams,
+  DeleteQueryOptions,
+  BulkOptions,
+  BatchGoRecord
+} from './options';
+import {
+  WhereClause, 
+  DataUpdateMethod,
+} from './where';
+
+import {
+  AllTableIndexCompositeAttributes, 
+  IndexCompositeAttributes, 
+  ResponseItem, 
+  IndexWithSortKey, 
+  IndexSKAttributes, 
+  Item, 
+  Schema, 
+  SetItem, 
+  UpdateData, 
+  AddItem, 
+  SubtractItem, 
+  AppendItem, 
+  DeleteItem,
+} from './schema';
+
+
+export interface RecordsActionOptions<A extends string, 
+F extends string, C extends string, S extends Schema<A,F,C>, Items, IndexCompositeAttributes> {
+  go: GoRecord<Items>;
+  params: ParamRecord;
+  page: PageRecord<Items,IndexCompositeAttributes>;
+  where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Items,IndexCompositeAttributes>>;
+}
+
+export interface SingleRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+  go: GoRecord<ResponseType, QueryOptions>;
+  params: ParamRecord<QueryOptions>;
+  where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,SingleRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface PutRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+  go: GoRecord<ResponseType, PutQueryOptions>;
+  params: ParamRecord<PutQueryOptions>;
+  where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface UpdateRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+  go: GoRecord<ResponseType, UpdateQueryOptions>;
+  params: ParamRecord<UpdateQueryParams>;
+  where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,PutRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface DeleteRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType> {
+  go: GoRecord<ResponseType, DeleteQueryOptions>;
+  params: ParamRecord<DeleteQueryOptions>;
+  where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,DeleteRecordOperationOptions<A,F,C,S,ResponseType>>;
+}
+
+export interface BulkRecordOperationOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, ResponseType, AlternateResponseType> {
+  go: BatchGoRecord<ResponseType, AlternateResponseType>;
+  params: ParamRecord<BulkOptions>;
+}
+
+export interface SetRecordActionOptions<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr,IndexCompositeAttributes,TableItem> {
+  go: GoRecord<Partial<TableItem>, UpdateQueryOptions>;
+  params: ParamRecord<UpdateQueryParams>;
+  set: SetRecord<A,F,C,S, SetItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+  remove: SetRecord<A,F,C,S, Array<keyof SetItem<A,F,C,S>>,IndexCompositeAttributes,TableItem>;
+  add: SetRecord<A,F,C,S, AddItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+  subtract: SetRecord<A,F,C,S, SubtractItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+  append: SetRecord<A,F,C,S, AppendItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+  delete: SetRecord<A,F,C,S, DeleteItem<A,F,C,S>,IndexCompositeAttributes,TableItem>;
+  data: DataUpdateMethodRecord<A,F,C,S, Item<A,F,C,S,S["attributes"]>,IndexCompositeAttributes,TableItem>;
+  where: WhereClause<A,F,C,S, Item<A,F,C,S,S["attributes"]>,SetRecordActionOptions<A,F,C,S,SetAttr,IndexCompositeAttributes,TableItem>>;
+}
+
+export type SetRecord<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> = (properties: SetAttr) => SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>;
+export type RemoveRecord<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, RemoveAttr, IndexCompositeAttributes, TableItem> = (properties: RemoveAttr) => SetRecordActionOptions<A,F,C,S, RemoveAttr, IndexCompositeAttributes, TableItem>;
+
+export type DataUpdateMethodRecord<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, SetAttr, IndexCompositeAttributes, TableItem> =
+    DataUpdateMethod<A,F,C,S, UpdateData<A,F,C,S>, SetRecordActionOptions<A,F,C,S, SetAttr, IndexCompositeAttributes, TableItem>>
+
+interface QueryOperations<A extends string, F extends string, C extends string, S extends Schema<A,F,C>, CompositeAttributes, TableItem, IndexCompositeAttributes> {
+  between: (skCompositeAttributesStart: CompositeAttributes, skCompositeAttributesEnd: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+  gt: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+  gte: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+  lt: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+  lte: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+  begins: (skCompositeAttributes: CompositeAttributes) => RecordsActionOptions<A,F,C,S, Array<TableItem>,IndexCompositeAttributes>;
+  go: GoRecord<Array<TableItem>>;
+  params: ParamRecord;
+  page: PageRecord<Array<TableItem>,IndexCompositeAttributes>;
+  where: WhereClause<A,F,C,S,Item<A,F,C,S,S["attributes"]>,RecordsActionOptions<A,F,C,S,Array<TableItem>,IndexCompositeAttributes>>
+}
+
+export type Queries<A extends string, F extends string, C extends string, S extends Schema<A,F,C>> = {
+  [I in keyof S["indexes"]]: <CompositeAttributes extends IndexCompositeAttributes<A,F,C,S,I>>(composite: CompositeAttributes) =>
+      IndexSKAttributes<A,F,C,S,I> extends infer SK
+          // If there is no SK, dont show query operations (when an empty array is provided)
+          ? [keyof SK] extends [never]
+              ? RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes>>
+              // If there is no SK, dont show query operations (When no PK is specified)
+              : S["indexes"][I] extends IndexWithSortKey
+                  ? QueryOperations<
+                      A,F,C,S,
+                      // Omit the composite attributes already provided
+                      Omit<Partial<IndexSKAttributes<A,F,C,S,I>>, keyof CompositeAttributes>,
+                      ResponseItem<A,F,C,S>,
+                      AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes> & SK
+                      >
+                  : RecordsActionOptions<A,F,C,S, ResponseItem<A,F,C,S>[], AllTableIndexCompositeAttributes<A,F,C,S> & Required<CompositeAttributes> & SK>
+          : never
+}
+
+export type ParseSingleInput = {
+  Item?: {[key: string]: any}
+} | {
+  Attributes?: {[key: string]: any}
+} | null;
+
+export type ParseMultiInput = {
+  Items?: {[key: string]: any}[]
+}
+

package/src/types/options.ts

@@ -0,0 +1,81 @@
+import { ElectroEventListener } from './events';
+
+export type ReturnValues = "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+
+export interface QueryOptions {
+    raw?: boolean;
+    table?: string;
+    limit?: number;
+    params?: object;
+    includeKeys?: boolean;
+    originalErr?: boolean;
+    ignoreOwnership?: boolean;
+    pages?: number;
+    listeners?: Array<ElectroEventListener>;
+    logger?: ElectroEventListener;
+}
+
+// subset of QueryOptions
+export interface ParseOptions {
+    ignoreOwnership?: boolean;
+}
+
+export interface UpdateQueryOptions extends QueryOptions {
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+}
+
+export interface UpdateQueryParams {
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+    table?: string;
+    params?: object;
+    originalErr?: boolean;
+}
+
+export interface DeleteQueryOptions extends QueryOptions {
+    response?: "default" | "none" | 'all_old';
+}
+
+export interface PutQueryOptions extends QueryOptions {
+    response?: "default" | "none" | 'all_old';
+}
+
+export interface ParamOptions {
+    params?: object;
+    table?: string;
+    limit?: number;
+    response?: "default" | "none" | 'all_old' | 'updated_old' | 'all_new' | 'updated_new';
+}
+
+export interface PaginationOptions extends QueryOptions {
+    pager?: "raw" | "item" | "named";
+    limit?: number;
+}
+
+export interface BulkOptions extends QueryOptions {
+    unprocessed?: "raw" | "item";
+    concurrency?: number;
+    preserveBatchOrder?: boolean;
+}
+
+export type OptionalDefaultEntityIdentifiers = {
+    __edb_e__?: string;
+    __edb_v__?: string;
+}
+
+export type GoRecord<ResponseType, Options = QueryOptions> = <T = ResponseType>(options?: Options) => Promise<T>;
+
+export type BatchGoRecord<ResponseType, AlternateResponseType> = <O extends BulkOptions>(options?: O) =>
+    O extends infer Options
+        ? 'preserveBatchOrder' extends keyof Options
+        ? Options['preserveBatchOrder'] extends true
+            ? Promise<AlternateResponseType>
+            : Promise<ResponseType>
+        : Promise<ResponseType>
+        : never
+
+export type PageRecord<ResponseType, CompositeAttributes> = (page?: (CompositeAttributes & OptionalDefaultEntityIdentifiers) | null, options?: PaginationOptions) => Promise<[
+    (CompositeAttributes & OptionalDefaultEntityIdentifiers) | null,
+    ResponseType
+]>;
+
+export type ParamRecord<Options = ParamOptions> = <P>(options?: Options) => P;