electrodb 3.6.2 → 3.7.1

package/index.d.ts

@@ -30,6 +30,7 @@ export type DocumentClient =
       scan: DocumentClientMethod;
       transactGet: DocumentClientMethod;
       transactWrite: DocumentClientMethod;
+      query: DocumentClientMethod;
     }
   | {
       send: (command: any) => Promise<any>;
@@ -2631,6 +2632,7 @@ export interface QueryOptions {
   data?: "raw" | "includeKeys" | "attributes";
   order?: "asc" | "desc";
   consistent?: boolean;
+  client?: DocumentClient;
 }
 
 // subset of QueryOptions
@@ -2720,6 +2722,7 @@ interface GoBatchGetTerminalOptions<Attributes> {
   listeners?: Array<ElectroEventListener>;
   logger?: ElectroEventListener;
   consistent?: boolean;
+  client?: DocumentClient;
 }
 
 export type ExecutionOptionCompare = "keys" | "attributes" | "v2";
@@ -2751,6 +2754,7 @@ type ServiceQueryGoTerminalOptions<
   logger?: ElectroEventListener;
   order?: "asc" | "desc";
   consistent?: boolean;
+  client?: DocumentClient;
 } & QueryExecutionComparisonParts &
   (
     | {
@@ -2819,6 +2823,7 @@ type GoQueryTerminalOptions<
   order?: "asc" | "desc";
   hydrate?: boolean;
   consistent?: boolean;
+  client?: DocumentClient;
 } & QueryExecutionComparisonParts &
   (
     | {
@@ -2846,6 +2851,7 @@ interface TransactWriteQueryOptions {
   listeners?: Array<ElectroEventListener>;
   logger?: ElectroEventListener;
   response?: "all_old";
+  client?: DocumentClient;
 }
 
 interface TransactGetQueryOptions<Attributes> {
@@ -2858,6 +2864,7 @@ interface TransactGetQueryOptions<Attributes> {
   listeners?: Array<ElectroEventListener>;
   logger?: ElectroEventListener;
   consistent?: boolean;
+  client?: DocumentClient;
 }
 
 export type ParamTerminalOptions<Attributes> = {
@@ -3957,7 +3964,7 @@ export type NestedAttributes =
 
 export interface IndexWithSortKey {
   readonly sk: {
-    readonly field: string;
+    readonly field?: string;
     readonly composite: ReadonlyArray<string>;
     readonly template?: string;
   };
@@ -3988,19 +3995,19 @@ export interface Schema<A extends string, F extends string, C extends string, P
       readonly projection?: "all" | "keys_only" | ReadonlyArray<P>;
       readonly index?: string;
       readonly scope?: string;
-      readonly type?: "clustered" | "isolated";
+      readonly type?: "clustered" | "isolated" | "composite";
       readonly collection?: AccessPatternCollection<C>;
       readonly condition?: (composite: Record<string, unknown>) => boolean;
       readonly pk: {
         readonly casing?: KeyCasingOption;
-        readonly field: string;
+        readonly field?: string;
         readonly composite: ReadonlyArray<F>;
         readonly template?: string;
         readonly cast?: KeyCastOption;
       };
       readonly sk?: {
         readonly casing?: KeyCasingOption;
-        readonly field: string;
+        readonly field?: string;
         readonly composite: ReadonlyArray<F>;
         readonly template?: string;
         readonly cast?: KeyCastOption;
@@ -4084,7 +4091,7 @@ type ClusteredIndexNameMap<
   C extends string,
   S extends Schema<A, F, C>,
 > = {
-  [I in keyof S["indexes"] as S["indexes"][I] extends { type: "clustered" }
+  [I in keyof S["indexes"] as S["indexes"][I] extends { type: "clustered" | "composite" }
     ? I
     : never]: S["indexes"][I]["collection"] extends AccessPatternCollection<
     infer Name
@@ -4101,7 +4108,7 @@ type IsolatedIndexNameMap<
   C extends string,
   S extends Schema<A, F, C>,
 > = {
-  [I in keyof S["indexes"] as S["indexes"][I] extends { type: "clustered" }
+  [I in keyof S["indexes"] as S["indexes"][I] extends { type: "clustered" | "composite" }
     ? never
     : I]: S["indexes"][I]["collection"] extends AccessPatternCollection<
     infer Name
@@ -5898,9 +5905,14 @@ export class TransactGetEntity<
 type TransactWriteFunctionOptions = {
   token?: string;
   logger?: ElectroEventListener;
+  client?: DocumentClient;
 };
 
-type TransactGetFunctionOptions = {};
+type TransactGetFunctionOptions = {
+  token?: string;
+  logger?: ElectroEventListener;
+  client?: DocumentClient;
+};
 
 type TransactWriteExtractedType<
   T extends readonly any[],

package/package.json

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

package/src/clauses.js

@@ -22,6 +22,72 @@ const v = require("./validations");
 const e = require("./errors");
 const u = require("./util");
 
+function handleNonIsolatedCollection(
+  entity,
+  state,
+  collection = "",
+  facets /* istanbul ignore next */ = {},
+) {
+  if (state.getError() !== null) {
+    return state;
+  }
+  try {
+    const { pk, sk } = state.getCompositeAttributes();
+    return state
+      .setMethod(MethodTypes.query)
+      .setCollection(collection)
+      .setPK(entity._expectFacets(facets, pk))
+      .ifSK(() => {
+        const { composites, unused } = state.identifyCompositeAttributes(
+          facets,
+          sk,
+          pk,
+        );
+        state.setSK(composites);
+        state.beforeBuildParams(({ options, state }) => {
+          const accessPattern =
+            entity.model.translations.indexes.fromIndexToAccessPattern[
+              state.query.index
+            ];
+
+          if (
+            options.compare === ComparisonTypes.attributes ||
+            options.compare === ComparisonTypes.v2
+          ) {
+            if (
+              !entity.model.indexes[accessPattern].sk.isFieldRef &&
+              sk.length > 1
+            ) {
+              state.filterProperties(FilterOperationNames.eq, {
+                ...unused,
+                ...composites,
+              });
+            }
+          }
+        });
+      })
+      .whenOptions(({ options, state }) => {
+        if (!options.ignoreOwnership && !state.getParams()) {
+          state.query.options.expressions.names = {
+            ...state.query.options.expressions.names,
+            ...state.query.options.identifiers.names,
+          };
+          state.query.options.expressions.values = {
+            ...state.query.options.expressions.values,
+            ...state.query.options.identifiers.values,
+          };
+          state.query.options.expressions.expression =
+            state.query.options.expressions.expression.length > 1
+              ? `(${state.query.options.expressions.expression}) AND ${state.query.options.identifiers.expression}`
+              : `${state.query.options.identifiers.expression}`;
+        }
+      });
+  } catch (err) {
+    state.setError(err);
+    return state;
+  }
+}
+
 const methodChildren = {
   upsert: [
     "upsertSet",
@@ -86,6 +152,7 @@ let clauses = {
       "scan",
       "collection",
       "clusteredCollection",
+      "compositeCollection",
       "create",
       "remove",
       "patch",
@@ -94,6 +161,23 @@ let clauses = {
       "batchGet",
     ],
   },
+  compositeCollection: {
+    name: "compositeCollection",
+    action(
+      entity,
+      state,
+      collection = "",
+      facets /* istanbul ignore next */ = {},
+    ) {
+      return handleNonIsolatedCollection(
+        entity,
+        state.setType(QueryTypes.composite_collection),
+        collection,
+        facets,
+      );
+    },
+    children: ["between", "gte", "gt", "lte", "lt", "begins", "params", "go"],
+  },
   clusteredCollection: {
     name: "clusteredCollection",
     action(
@@ -102,65 +186,12 @@ let clauses = {
       collection = "",
       facets /* istanbul ignore next */ = {},
     ) {
-      if (state.getError() !== null) {
-        return state;
-      }
-      try {
-        const { pk, sk } = state.getCompositeAttributes();
-        return state
-          .setType(QueryTypes.clustered_collection)
-          .setMethod(MethodTypes.query)
-          .setCollection(collection)
-          .setPK(entity._expectFacets(facets, pk))
-          .ifSK(() => {
-            const { composites, unused } = state.identifyCompositeAttributes(
-              facets,
-              sk,
-              pk,
-            );
-            state.setSK(composites);
-            state.beforeBuildParams(({ options, state }) => {
-              const accessPattern =
-                entity.model.translations.indexes.fromIndexToAccessPattern[
-                  state.query.index
-                ];
-
-              if (
-                options.compare === ComparisonTypes.attributes ||
-                options.compare === ComparisonTypes.v2
-              ) {
-                if (
-                  !entity.model.indexes[accessPattern].sk.isFieldRef &&
-                  sk.length > 1
-                ) {
-                  state.filterProperties(FilterOperationNames.eq, {
-                    ...unused,
-                    ...composites,
-                  });
-                }
-              }
-            });
-          })
-          .whenOptions(({ options, state }) => {
-            if (!options.ignoreOwnership && !state.getParams()) {
-              state.query.options.expressions.names = {
-                ...state.query.options.expressions.names,
-                ...state.query.options.identifiers.names,
-              };
-              state.query.options.expressions.values = {
-                ...state.query.options.expressions.values,
-                ...state.query.options.identifiers.values,
-              };
-              state.query.options.expressions.expression =
-                state.query.options.expressions.expression.length > 1
-                  ? `(${state.query.options.expressions.expression}) AND ${state.query.options.identifiers.expression}`
-                  : `${state.query.options.identifiers.expression}`;
-            }
-          });
-      } catch (err) {
-        state.setError(err);
-        return state;
-      }
+      return handleNonIsolatedCollection(
+        entity,
+        state.setType(QueryTypes.clustered_collection),
+        collection,
+        facets,
+      );
     },
     children: ["between", "gte", "gt", "lte", "lt", "begins", "params", "go"],
   },
@@ -1327,10 +1358,10 @@ let clauses = {
         return Promise.reject(state.error);
       }
       try {
-        if (entity.client === undefined) {
+        if (entity.client === undefined && options.client === undefined) {
           throw new e.ElectroError(
             e.ErrorCodes.NoClientDefined,
-            "No client defined on model",
+            "No client defined on model or provided in query options",
           );
         }
         options.terminalOperation = TerminalOperation.go;