@moicky/dynamodb 3.0.3 → 3.0.5

package/dist/index.d.ts

@@ -2,6 +2,6 @@ export * from "./lib";
 export * from "./operations";
 export * from "./transactions";
 export { createCustomReference, getDependencies, resolveReferences, } from "./transactions/references";
-export type { DynamoDBItemKey, ItemWithKey, Prettify, DynamoDBSet, } from "./transactions/types";
 export type { DynamoDBReference, ReferenceMetadata, ReferenceTo, ResolvedItem, WithoutReferences, } from "./transactions/references/types";
+export type { DynamoDBItemKey, ItemWithKey, Prettify, } from "./transactions/types";
 export type * from "./types";

package/dist/operations/get.js

@@ -41,12 +41,12 @@ async function getItem(key, args = {}) {
 }
 exports.getItem = getItem;
 async function getItems(keys, args = {}, retry = 0) {
+    if (keys.length === 0)
+        return [];
     args = (0, lib_1.withDefaults)(args, "getItems");
     // creates batches of 100 items each and performs batchGet on every batch.
     // also retries up to 3 times if there are unprocessed items (due to size limit of 16MB)
     // returns items in same order as keys (not sorted by default when using batchGet)
-    if (retry > 3)
-        return [];
     const batchReadLimit = 100;
     // duplicate key entries would cause an error, so we remove them
     const uniqueKeys = Object.values(keys.reduce((acc, key) => {

package/dist/transactions/operations.d.ts

@@ -1,7 +1,7 @@
 import { Transaction } from ".";
 import { DynamoDBItem } from "../types";
 import { DynamoDBReference } from "./references/types";
-import { ConditionOperation, CreateOperation, DynamoDBItemKey, DynamoDBSet, ItemWithKey, NestedParams, NestedTypedParams, TypedParams, UpdateOperation, WithoutKey } from "./types";
+import { ConditionOperation, CreateOperation, DeepSetUpdates, DynamoDBItemKey, ItemWithKey, NestedParams, Prettify, StrictDeepNumberUpdates, TypedParams, UpdateOperation, WithoutKey } from "./types";
 export declare class CreateOperations<U extends ItemWithKey> {
     private operation;
     private transaction;
@@ -14,12 +14,10 @@ export declare class UpdateOperations<U extends DynamoDBItem> {
     constructor(operation: UpdateOperation, transaction: Transaction);
     setReferences(refs: SetReferencesParams<U>): void;
     set(values: WithoutKey<Partial<U>> & NestedParams): this;
-    adjustNumber(values: NestedTypedParams<U, number>): this;
+    adjustNumber(values: Prettify<StrictDeepNumberUpdates<U>>): this;
     removeAttributes(...attributes: string[]): this;
-    addItemsToSet(values: {
-        [Key in keyof U as NonNullable<U[Key]> extends DynamoDBSet ? Key : never]?: U[Key] extends Set<infer type> ? Set<type> | type[] : never;
-    } & NestedParams<Set<any> | any[]>): this;
-    deleteItemsFromSet(values: NestedTypedParams<U, Set<any>>): this;
+    addItemsToSet(values: Prettify<DeepSetUpdates<U>>): this;
+    deleteItemsFromSet(values: Prettify<DeepSetUpdates<U>>): this;
     onCondition({ expression, values, }: {
         expression: string;
         values: Partial<U> & Record<string, any>;

package/dist/transactions/operations.js

@@ -69,7 +69,7 @@ class UpdateOperations {
     adjustNumber(values) {
         if (Object.keys(values).length === 0)
             return this;
-        this.operation.actions.push({ _type: "add", values });
+        this.operation.actions.push({ _type: "add", values: values });
         return this;
     }
     removeAttributes(...attributes) {

package/dist/transactions/types.d.ts

@@ -50,5 +50,33 @@ export type TypedParams<T extends DynamoDBItem, ValueType, ParamType = ValueType
 };
 export type NestedParams<T = any> = Record<`${string}.${string}`, T>;
 export type NestedTypedParams<T extends DynamoDBItem, ValueType, ParamType = ValueType> = TypedParams<T, ValueType, ParamType> & NestedParams<ParamType>;
-export type DynamoDBSetMember = number | string | undefined;
-export type DynamoDBSet = Set<DynamoDBSetMember>;
+type Prev = [never, 0, 1, 2, 3];
+type DeepNumberPathEntries<T, Prefix extends string = "", D extends number = 3> = [D] extends [never] ? never : {
+    [K in keyof T & string]-?: NonNullable<T[K]> extends number ? {
+        path: `${Prefix}${K}`;
+        type: NonNullable<T[K]>;
+    } : NonNullable<T[K]> extends any[] | Set<any> | Date | Function | Uint8Array ? never : NonNullable<T[K]> extends object ? DeepNumberPathEntries<NonNullable<T[K]>, `${Prefix}${K}.`, Prev[D]> : never;
+}[keyof T & string];
+export type StrictDeepNumberUpdates<T> = {
+    [E in DeepNumberPathEntries<T> as E extends {
+        path: string;
+    } ? E["path"] : never]?: E extends {
+        type: infer V;
+    } ? V : never;
+};
+type DeepSetPathEntries<T, Prefix extends string = "", D extends number = 3> = [
+    D
+] extends [never] ? never : {
+    [K in keyof T & string]-?: NonNullable<T[K]> extends Set<infer E> | (infer E)[] ? {
+        path: `${Prefix}${K}`;
+        type: E;
+    } : NonNullable<T[K]> extends Date | Function | Uint8Array ? never : NonNullable<T[K]> extends object ? DeepSetPathEntries<NonNullable<T[K]>, `${Prefix}${K}.`, Prev[D]> : never;
+}[keyof T & string];
+export type DeepSetUpdates<T> = {
+    [E in DeepSetPathEntries<T> as E extends {
+        path: string;
+    } ? E["path"] : never]?: E extends {
+        type: infer V;
+    } ? V[] | Set<V> : never;
+};
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moicky/dynamodb",
-  "version": "3.0.3",
+  "version": "3.0.5",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "description": "Contains a collection of convenience functions for working with AWS DynamoDB",