@moicky/dynamodb 1.3.1 → 2.0.1

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./lib/client";
+export * from "./lib";
 export * from "./operations";

package/dist/index.js

@@ -14,5 +14,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/client"), exports);
+__exportStar(require("./lib"), exports);
 __exportStar(require("./operations"), exports);

package/dist/lib/client.d.ts

@@ -1,51 +1,3 @@
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-import { deleteItem, deleteItems, getItem, getItems, getAllItems, putItem, putItems, query, queryItems, queryAllItems, updateItem, removeAttributes } from "../operations";
-interface OperationArguments {
-    deleteItem?: Parameters<typeof deleteItem>[1];
-    deleteItems?: Parameters<typeof deleteItems>[1];
-    getItem?: Parameters<typeof getItem>[1];
-    getItems?: Parameters<typeof getItems>[1];
-    getAllItems?: Parameters<typeof getAllItems>[0];
-    putItem?: Parameters<typeof putItem>[1];
-    putItems?: Parameters<typeof putItems>[1];
-    query?: Parameters<typeof query>[2];
-    queryItems?: Parameters<typeof queryItems>[2];
-    queryAllItems?: Parameters<typeof queryAllItems>[2];
-    updateItem?: Parameters<typeof updateItem>[2];
-    removeAttributes?: Parameters<typeof removeAttributes>[2];
-}
-type Operation = keyof OperationArguments;
-declare interface KeySchema {
-    hash: string;
-    range?: string;
-}
-declare interface KeySchemaCollection {
-    [tableName: string]: KeySchema;
-}
-declare class DynamoDBConfig {
-    #private;
-    client: DynamoDBClient;
-    tablesSchema: KeySchemaCollection;
-    constructor({ region }?: {
-        region?: string;
-    });
-    initSchema(schema: KeySchemaCollection): KeySchemaCollection;
-    getDefaultTable(): string;
-    getTableSchema(tableName?: string): KeySchema;
-    getDefaultTableSchema(): KeySchema;
-    validateSchema(schema: KeySchemaCollection): boolean;
-    initDefaults(newDefaults: OperationArguments): void;
-    withDefaults<T extends Operation>(args: OperationArguments[T], operation: T): OperationArguments[T];
-    destroy(): void;
-}
-declare const config: DynamoDBConfig;
-export declare const client: DynamoDBClient;
-export declare const initSchema: (schema: KeySchemaCollection) => KeySchemaCollection;
-export declare const getDefaultTable: () => string;
-export declare const getDefaultTableSchema: () => KeySchema;
-export declare const validateSchema: (schema: KeySchemaCollection) => boolean;
-export declare const getTableSchema: (tableName?: string) => KeySchema;
-export declare const initDefaults: (newDefaults: OperationArguments) => void;
-export declare const withDefaults: <T extends keyof OperationArguments>(args: OperationArguments[T], operation: T) => OperationArguments[T];
-export declare const destroy: () => void;
-export default config;
+export declare const initClient: (newClient: DynamoDBClient) => void;
+export declare const getClient: () => DynamoDBClient;

package/dist/lib/client.js

@@ -1,94 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.destroy = exports.withDefaults = exports.initDefaults = exports.getTableSchema = exports.validateSchema = exports.getDefaultTableSchema = exports.getDefaultTable = exports.initSchema = exports.client = void 0;
+exports.getClient = exports.initClient = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-class DynamoDBConfig {
-    client;
-    tablesSchema = {};
-    #initialized = false;
-    #defaults = {};
-    constructor({ region } = {}) {
-        this.client = new client_dynamodb_1.DynamoDBClient({
-            region: region || process.env.AWS_REGION || "eu-central-1",
-        });
-        const defaultTable = process.env.DYNAMODB_TABLE;
-        if (defaultTable) {
-            this.initSchema({
-                [defaultTable]: {
-                    hash: "PK",
-                    range: "SK",
-                },
-            });
-        }
-    }
-    initSchema(schema) {
-        if (!this.validateSchema(schema)) {
-            throw new Error("Invalid schema");
-        }
-        this.tablesSchema = Object.keys(schema).reduce((acc, table) => {
-            const { hash, range } = schema[table];
-            acc[table] = {
-                hash: hash + "",
-                ...(range && { range: range + "" }),
-            };
-            return acc;
-        }, {});
-        this.#initialized = true;
-        return this.tablesSchema;
-    }
-    getDefaultTable() {
-        if (!this.#initialized) {
-            throw new Error("Schema not initialized");
-        }
-        return Object.keys(this.tablesSchema)[0];
-    }
-    getTableSchema(tableName) {
-        if (!this.#initialized) {
-            throw new Error("Schema not initialized");
-        }
-        const table = tableName || this.getDefaultTable();
-        return this.tablesSchema[table] || this.getDefaultTableSchema();
-    }
-    getDefaultTableSchema() {
-        return { hash: "PK", range: "SK" };
-    }
-    validateSchema(schema) {
-        const tables = Object.keys(schema);
-        if (tables.length === 0) {
-            throw new Error("No tables provided");
-        }
-        tables.forEach((table) => {
-            const { hash } = schema[table];
-            if (!hash) {
-                throw new Error(`No hash key provided for table ${table}`);
-            }
-        });
-        return true;
-    }
-    initDefaults(newDefaults) {
-        this.#defaults = { ...newDefaults };
-    }
-    withDefaults(args, operation) {
-        return {
-            ...this.#defaults[operation],
-            ...args,
-        };
-    }
-    destroy() {
-        this.client.destroy();
-    }
+const schemas_1 = require("./schemas");
+let client = new client_dynamodb_1.DynamoDBClient({
+    region: process.env.AWS_REGION || "eu-central-1",
+});
+const defaultTable = process.env.DYNAMODB_TABLE;
+if (defaultTable) {
+    (0, schemas_1.initSchema)({ [defaultTable]: (0, schemas_1.getDefaultTableSchema)() });
 }
-const config = new DynamoDBConfig();
-const bind = (fn) => {
-    return fn.bind(config);
+const initClient = (newClient) => {
+    client = newClient;
 };
-exports.client = config.client;
-exports.initSchema = bind(config.initSchema);
-exports.getDefaultTable = bind(config.getDefaultTable);
-exports.getDefaultTableSchema = bind(config.getDefaultTableSchema);
-exports.validateSchema = bind(config.validateSchema);
-exports.getTableSchema = bind(config.getTableSchema);
-exports.initDefaults = bind(config.initDefaults);
-exports.withDefaults = bind(config.withDefaults);
-exports.destroy = bind(config.destroy);
-exports.default = config;
+exports.initClient = initClient;
+const getClient = () => client;
+exports.getClient = getClient;

package/dist/lib/defaultArguments.d.ts

@@ -0,0 +1,19 @@
+import { deleteItem, deleteItems, getAllItems, getItem, getItems, itemExists, putItem, putItems, query, queryAllItems, queryItems, removeAttributes, updateItem } from "../operations";
+export interface OperationArguments {
+    deleteItem?: Parameters<typeof deleteItem>[1];
+    deleteItems?: Parameters<typeof deleteItems>[1];
+    getItem?: Parameters<typeof getItem>[1];
+    getItems?: Parameters<typeof getItems>[1];
+    getAllItems?: Parameters<typeof getAllItems>[0];
+    itemExists?: Parameters<typeof itemExists>[1];
+    putItem?: Parameters<typeof putItem>[1];
+    putItems?: Parameters<typeof putItems>[1];
+    query?: Parameters<typeof query>[2];
+    queryItems?: Parameters<typeof queryItems>[2];
+    queryAllItems?: Parameters<typeof queryAllItems>[2];
+    updateItem?: Parameters<typeof updateItem>[2];
+    removeAttributes?: Parameters<typeof removeAttributes>[2];
+}
+export declare const initDefaultArguments: (args: OperationArguments) => void;
+export declare const getDefaultArguments: () => OperationArguments;
+export declare const withDefaults: <T extends keyof OperationArguments>(args: Partial<OperationArguments[T]>, operation: T) => OperationArguments[T];

package/dist/lib/defaultArguments.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withDefaults = exports.getDefaultArguments = exports.initDefaultArguments = void 0;
+let defaultArguments = {};
+const initDefaultArguments = (args) => {
+    defaultArguments = args;
+};
+exports.initDefaultArguments = initDefaultArguments;
+const getDefaultArguments = () => defaultArguments;
+exports.getDefaultArguments = getDefaultArguments;
+const withDefaults = (args, operation) => {
+    return {
+        ...defaultArguments[operation],
+        ...args,
+    };
+};
+exports.withDefaults = withDefaults;

package/dist/lib/fixes.d.ts

@@ -0,0 +1,16 @@
+import { QueryCommandInput, ScanCommandInput } from "@aws-sdk/client-dynamodb";
+import { marshall, marshallOptions, unmarshall, unmarshallOptions } from "@aws-sdk/util-dynamodb";
+export declare interface DynamoDBFixes {
+    disableConsistantReadWhenUsingIndexes?: {
+        enabled: boolean;
+        stillUseOnLocalIndexes?: string[];
+    };
+    marshallOptions?: marshallOptions;
+    unmarshallOptions?: unmarshallOptions;
+}
+export declare const initFixes: (fixesConfig: DynamoDBFixes) => void;
+export declare const getFixes: () => DynamoDBFixes;
+export declare const withFixes: (args: Partial<QueryCommandInput> | Partial<ScanCommandInput>) => Partial<QueryCommandInput> | Partial<ScanCommandInput>;
+export declare const getDefaultFixes: () => DynamoDBFixes;
+export declare const marshallWithOptions: (input: Parameters<typeof marshall>[0]) => Record<string, import("@aws-sdk/client-dynamodb").AttributeValue>;
+export declare const unmarshallWithOptions: (input: Parameters<typeof unmarshall>[0]) => Record<string, any>;

package/dist/lib/fixes.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unmarshallWithOptions = exports.marshallWithOptions = exports.getDefaultFixes = exports.withFixes = exports.getFixes = exports.initFixes = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const defaults = Object.freeze({
+    disableConsistantReadWhenUsingIndexes: {
+        enabled: true,
+    },
+});
+let fixes = defaults;
+const initFixes = (fixesConfig) => {
+    fixes = fixesConfig;
+};
+exports.initFixes = initFixes;
+const getFixes = () => fixes;
+exports.getFixes = getFixes;
+const handleIndex = (args) => {
+    if (fixes?.disableConsistantReadWhenUsingIndexes?.enabled &&
+        args?.IndexName &&
+        args?.ConsistentRead &&
+        !fixes?.disableConsistantReadWhenUsingIndexes?.stillUseOnLocalIndexes?.includes(args?.IndexName)) {
+        args.ConsistentRead = false;
+    }
+};
+const withFixes = (args) => {
+    handleIndex(args);
+    return args;
+};
+exports.withFixes = withFixes;
+const getDefaultFixes = () => defaults;
+exports.getDefaultFixes = getDefaultFixes;
+const marshallWithOptions = (input) => (0, util_dynamodb_1.marshall)(input, fixes.marshallOptions);
+exports.marshallWithOptions = marshallWithOptions;
+const unmarshallWithOptions = (input) => (0, util_dynamodb_1.unmarshall)(input, fixes.unmarshallOptions);
+exports.unmarshallWithOptions = unmarshallWithOptions;

package/dist/lib/helpers.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAttributesFromExpression = exports.getAttributeNames = exports.getAttributeValues = exports.splitEvery = exports.stripKey = void 0;
-const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
-const client_1 = require("../lib/client");
+const fixes_1 = require("./fixes");
+const schemas_1 = require("./schemas");
 // Since dynamo only accepts key atrtributes which are described in table schema
 // we remove any other attributes from the item if they are present and passed as
 // key parameter to any of the functions below (getItem, updateItem, deleteItem...)
 function stripKey(key, args) {
-    const { hash, range } = (0, client_1.getTableSchema)(args?.TableName);
-    return (0, util_dynamodb_1.marshall)({
+    const { hash, range } = (0, schemas_1.getTableSchema)(args?.TableName);
+    return (0, fixes_1.marshallWithOptions)({
         [hash]: key[hash],
         ...(range && { [range]: key[range] }),
     });
@@ -23,7 +23,7 @@ function splitEvery(items, limit = 25) {
 }
 exports.splitEvery = splitEvery;
 function getAttributeValues(key, attributesToGet) {
-    return (0, util_dynamodb_1.marshall)((attributesToGet || Object.keys(key)).reduce((acc, keyName) => {
+    return (0, fixes_1.marshallWithOptions)((attributesToGet || Object.keys(key)).reduce((acc, keyName) => {
         acc[`:${keyName}`] = key[keyName];
         return acc;
     }, {}));

package/dist/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./client";
+export * from "./defaultArguments";
+export * from "./fixes";
+export * from "./helpers";
+export * from "./schemas";

package/dist/lib/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./client"), exports);
+__exportStar(require("./defaultArguments"), exports);
+__exportStar(require("./fixes"), exports);
+__exportStar(require("./helpers"), exports);
+__exportStar(require("./schemas"), exports);

package/dist/lib/schemas.d.ts

@@ -0,0 +1,13 @@
+export declare interface KeySchema {
+    hash: string;
+    range?: string;
+}
+export declare interface KeySchemaCollection {
+    [tableName: string]: KeySchema;
+}
+export declare const initSchema: (schema: KeySchemaCollection) => KeySchemaCollection;
+export declare const validateSchema: (schema: KeySchemaCollection) => boolean;
+export declare const getDefaultTable: () => string;
+export declare const getTableSchema: (tableName?: string) => KeySchema;
+export declare const getDefaultTableSchema: () => KeySchema;
+export declare const isInitialized: () => boolean;

package/dist/lib/schemas.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInitialized = exports.getDefaultTableSchema = exports.getTableSchema = exports.getDefaultTable = exports.validateSchema = exports.initSchema = void 0;
+let initialized = false;
+let tablesSchema = {};
+const initSchema = (schema) => {
+    if (!(0, exports.validateSchema)(schema)) {
+        throw new Error("[@moicky/dynamodb]: Invalid schema");
+    }
+    tablesSchema = Object.keys(schema).reduce((acc, table) => {
+        const { hash, range } = schema[table];
+        acc[table] = {
+            hash: hash + "",
+            ...(range && { range: range + "" }),
+        };
+        return acc;
+    }, {});
+    initialized = true;
+    return tablesSchema;
+};
+exports.initSchema = initSchema;
+const validateSchema = (schema) => {
+    const tables = Object.keys(schema);
+    if (tables.length === 0) {
+        throw new Error("[@moicky/dynamodb]: No tables provided");
+    }
+    tables.forEach((table) => {
+        const { hash } = schema[table];
+        if (!hash) {
+            throw new Error(`No hash key provided for table ${table}`);
+        }
+        if (typeof hash !== "string") {
+            throw new Error(`Invalid hash key provided for table ${table}`);
+        }
+        const { range } = schema[table];
+        if (range && typeof range !== "string") {
+            throw new Error(`Invalid range key provided for table ${table}`);
+        }
+    });
+    return true;
+};
+exports.validateSchema = validateSchema;
+const getDefaultTable = () => {
+    if (!initialized) {
+        throw new Error("[@moicky/dynamodb]: Schema not initialized");
+    }
+    return Object.keys(tablesSchema)[0];
+};
+exports.getDefaultTable = getDefaultTable;
+const getTableSchema = (tableName) => {
+    if (!initialized) {
+        throw new Error("[@moicky/dynamodb]: Schema not initialized");
+    }
+    const table = tableName || (0, exports.getDefaultTable)();
+    return tablesSchema[table] || (0, exports.getDefaultTableSchema)();
+};
+exports.getTableSchema = getTableSchema;
+const getDefaultTableSchema = () => {
+    return { hash: "PK", range: "SK" };
+};
+exports.getDefaultTableSchema = getDefaultTableSchema;
+const isInitialized = () => initialized;
+exports.isInitialized = isInitialized;

package/dist/operations/delete.js

@@ -2,20 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteItems = exports.deleteItem = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const client_1 = require("../lib/client");
-const helpers_1 = require("../lib/helpers");
+const lib_1 = require("../lib");
 async function deleteItem(key, args = {}) {
-    return client_1.client.send(new client_dynamodb_1.DeleteItemCommand({
-        Key: (0, helpers_1.stripKey)(key, args),
-        ...(0, client_1.withDefaults)(args, "deleteItem"),
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+    return (0, lib_1.getClient)().send(new client_dynamodb_1.DeleteItemCommand({
+        Key: (0, lib_1.stripKey)(key, args),
+        ...(0, lib_1.withDefaults)(args, "deleteItem"),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }));
 }
 exports.deleteItem = deleteItem;
 async function deleteItems(keys, args = {}, retry = 0) {
-    args = (0, client_1.withDefaults)(args, "deleteItems");
+    args = (0, lib_1.withDefaults)(args, "deleteItems");
     const uniqueKeys = Object.values(keys.reduce((acc, key) => {
-        const strippedKey = (0, helpers_1.stripKey)(key, args);
+        const strippedKey = (0, lib_1.stripKey)(key, args);
         const keyString = JSON.stringify(strippedKey);
         if (!acc[keyString]) {
             acc[keyString] = strippedKey;
@@ -23,12 +22,12 @@ async function deleteItems(keys, args = {}, retry = 0) {
         return acc;
     }, {}));
     return new Promise(async (resolve, reject) => {
-        const batches = (0, helpers_1.splitEvery)(uniqueKeys);
+        const batches = (0, lib_1.splitEvery)(uniqueKeys);
         if (retry > 3)
             return;
-        const table = args?.TableName || (0, client_1.getDefaultTable)();
+        const table = args?.TableName || (0, lib_1.getDefaultTable)();
         for (const batch of batches) {
-            await client_1.client
+            await (0, lib_1.getClient)()
                 .send(new client_dynamodb_1.BatchWriteItemCommand({
                 RequestItems: {
                     [table]: batch.map((Key) => ({

package/dist/operations/get.js

@@ -2,22 +2,20 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllItems = exports.getItems = exports.getItem = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
-const client_1 = require("../lib/client");
-const helpers_1 = require("../lib/helpers");
+const lib_1 = require("../lib");
 async function getItem(key, args = {}) {
-    args = (0, client_1.withDefaults)(args, "getItem");
-    return client_1.client
+    args = (0, lib_1.withDefaults)(args, "getItem");
+    return (0, lib_1.getClient)()
         .send(new client_dynamodb_1.GetItemCommand({
-        Key: (0, helpers_1.stripKey)(key, args),
+        Key: (0, lib_1.stripKey)(key, args),
         ...args,
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }))
-        .then((res) => res?.Item && (0, util_dynamodb_1.unmarshall)(res.Item));
+        .then((res) => res?.Item && (0, lib_1.unmarshallWithOptions)(res.Item));
 }
 exports.getItem = getItem;
 async function getItems(keys, args = {}, retry = 0) {
-    args = (0, client_1.withDefaults)(args, "getItems");
+    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)
@@ -26,22 +24,22 @@ async function getItems(keys, args = {}, retry = 0) {
     const batchReadLimit = 100;
     // duplicate key entries would cause an error, so we remove them
     const uniqueKeys = Object.values(keys.reduce((acc, key) => {
-        const strippedKey = (0, helpers_1.stripKey)(key, args);
+        const strippedKey = (0, lib_1.stripKey)(key, args);
         const keyString = JSON.stringify(strippedKey);
         if (!acc[keyString]) {
             acc[keyString] = strippedKey;
         }
         return acc;
     }, {}));
-    const batches = (0, helpers_1.splitEvery)(uniqueKeys, batchReadLimit);
+    const batches = (0, lib_1.splitEvery)(uniqueKeys, batchReadLimit);
     const results = [];
     if (retry > 2) {
         return results;
     }
-    const TableName = args?.TableName || (0, client_1.getDefaultTable)();
+    const TableName = args?.TableName || (0, lib_1.getDefaultTable)();
     delete args.TableName;
     await Promise.all(batches.map(async (batch) => {
-        await client_1.client
+        await (0, lib_1.getClient)()
             .send(new client_dynamodb_1.BatchGetItemCommand({
             RequestItems: {
                 [TableName]: {
@@ -56,27 +54,27 @@ async function getItems(keys, args = {}, retry = 0) {
             if (unprocessed) {
                 return getItems(unprocessed.Keys, { ...args, TableName }, retry + 1).then((items) => allItemsFromBatch.concat(items));
             }
-            return allItemsFromBatch.map((item) => item && (0, util_dynamodb_1.unmarshall)(item));
+            return allItemsFromBatch.map((item) => item && (0, lib_1.unmarshallWithOptions)(item));
         })
             .then((items) => results.push(...items));
     }));
     const resultItems = results
         .filter((i) => i)
         .reduce((acc, item) => {
-        const keyString = JSON.stringify((0, helpers_1.stripKey)(item, { TableName }));
+        const keyString = JSON.stringify((0, lib_1.stripKey)(item, { TableName }));
         acc[keyString] = item;
         return acc;
     }, {});
-    return keys.map((key) => resultItems[JSON.stringify((0, helpers_1.stripKey)(key, { TableName }))] || undefined);
+    return keys.map((key) => resultItems[JSON.stringify((0, lib_1.stripKey)(key, { TableName }))] || undefined);
 }
 exports.getItems = getItems;
 async function getAllItems(args = {}) {
-    args = (0, client_1.withDefaults)(args, "getAllItems");
-    return client_1.client
+    args = (0, lib_1.withFixes)((0, lib_1.withDefaults)(args, "getAllItems"));
+    return (0, lib_1.getClient)()
         .send(new client_dynamodb_1.ScanCommand({
         ...args,
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }))
-        .then((res) => res.Items.map((item) => item && (0, util_dynamodb_1.unmarshall)(item)));
+        .then((res) => res.Items.map((item) => item && (0, lib_1.unmarshallWithOptions)(item)));
 }
 exports.getAllItems = getAllItems;

package/dist/operations/misc.js

@@ -1,21 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAscendingId = exports.itemExists = void 0;
-const client_1 = require("../lib/client");
-const get_1 = require("./get");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_1 = require("../lib");
 const query_1 = require("./query");
 async function itemExists(key, args = {}) {
-    return !!(await (0, get_1.getItem)(key, args));
+    args = (0, lib_1.withDefaults)(args, "itemExists");
+    return (0, lib_1.getClient)()
+        .send(new client_dynamodb_1.GetItemCommand({
+        Key: (0, lib_1.stripKey)(key, args),
+        ...args,
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
+    }))
+        .then((res) => !!res?.Item);
 }
 exports.itemExists = itemExists;
 async function getAscendingId({ length = 8, TableName, ...keySchema }) {
     // Assumes that you are the incrementing ID inside or as the keySchema range key
-    const table = TableName || (0, client_1.getDefaultTable)();
-    const { hash, range } = (0, client_1.getTableSchema)(table);
+    const table = TableName || (0, lib_1.getDefaultTable)();
+    const { hash, range } = (0, lib_1.getTableSchema)(table);
     const keySchemaHash = keySchema[hash];
     const keySchemaRange = keySchema[range];
     if (!keySchemaHash) {
-        throw new Error(`Cannot generate new ID: keySchemaHash is missing, expected '${hash}'`);
+        throw new Error(`[@moicky/dynamodb]: Cannot generate new ID: keySchemaHash is missing, expected '${hash}'`);
     }
     let lastId = "0";
     if (!keySchemaRange) {

package/dist/operations/put.js

@@ -2,40 +2,38 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.putItems = exports.putItem = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
-const client_1 = require("../lib/client");
-const helpers_1 = require("../lib/helpers");
+const lib_1 = require("../lib");
 async function putItem(data, args = {}) {
-    args = (0, client_1.withDefaults)(args, "putItem");
+    args = (0, lib_1.withDefaults)(args, "putItem");
     if (!Object.keys(data).includes("createdAt")) {
         data.createdAt = Date.now();
     }
-    return client_1.client
+    return (0, lib_1.getClient)()
         .send(new client_dynamodb_1.PutItemCommand({
-        Item: (0, util_dynamodb_1.marshall)(data),
+        Item: (0, lib_1.marshallWithOptions)(data),
         ...args,
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }))
-        .then((res) => (args?.ReturnValues ? (0, util_dynamodb_1.unmarshall)(res?.Attributes) : res));
+        .then((res) => args?.ReturnValues ? (0, lib_1.unmarshallWithOptions)(res?.Attributes) : res);
 }
 exports.putItem = putItem;
 async function putItems(items, args = {}) {
-    args = (0, client_1.withDefaults)(args, "putItems");
+    args = (0, lib_1.withDefaults)(args, "putItems");
     return new Promise(async (resolve, reject) => {
         const now = Date.now();
-        const batches = (0, helpers_1.splitEvery)(items.map((item) => ({
+        const batches = (0, lib_1.splitEvery)(items.map((item) => ({
             ...item,
             createdAt: item?.createdAt ?? now,
         })));
         const results = [];
-        const table = args?.TableName || (0, client_1.getDefaultTable)();
+        const table = args?.TableName || (0, lib_1.getDefaultTable)();
         for (const batch of batches) {
-            await client_1.client
+            await (0, lib_1.getClient)()
                 .send(new client_dynamodb_1.BatchWriteItemCommand({
                 RequestItems: {
                     [table]: batch.map((item) => ({
                         PutRequest: {
-                            Item: (0, util_dynamodb_1.marshall)(item),
+                            Item: (0, lib_1.marshallWithOptions)(item),
                         },
                     })),
                 },

package/dist/operations/query.js

@@ -2,37 +2,36 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryAllItems = exports.queryItems = exports.query = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
-const client_1 = require("../lib/client");
-const helpers_1 = require("../lib/helpers");
+const lib_1 = require("../lib");
 async function _query(keyCondition, key, args = {}) {
-    return client_1.client.send(new client_dynamodb_1.QueryCommand({
+    args = (0, lib_1.withFixes)(args);
+    return (0, lib_1.getClient)().send(new client_dynamodb_1.QueryCommand({
         KeyConditionExpression: keyCondition,
-        ExpressionAttributeValues: (0, helpers_1.getAttributeValues)(key, [
-            ...(0, helpers_1.getAttributesFromExpression)(keyCondition, ":"),
-            ...(0, helpers_1.getAttributesFromExpression)(args?.FilterExpression || "", ":"),
+        ExpressionAttributeValues: (0, lib_1.getAttributeValues)(key, [
+            ...(0, lib_1.getAttributesFromExpression)(keyCondition, ":"),
+            ...(0, lib_1.getAttributesFromExpression)(args?.FilterExpression || "", ":"),
         ]),
-        ExpressionAttributeNames: (0, helpers_1.getAttributeNames)(key, [
-            ...(0, helpers_1.getAttributesFromExpression)(keyCondition),
-            ...(0, helpers_1.getAttributesFromExpression)(args?.FilterExpression || ""),
+        ExpressionAttributeNames: (0, lib_1.getAttributeNames)(key, [
+            ...(0, lib_1.getAttributesFromExpression)(keyCondition),
+            ...(0, lib_1.getAttributesFromExpression)(args?.FilterExpression || ""),
         ]),
         ...args,
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }));
 }
 async function query(keyCondition, key, args) {
-    return _query(keyCondition, key, (0, client_1.withDefaults)(args, "query"));
+    return _query(keyCondition, key, (0, lib_1.withDefaults)(args, "query"));
 }
 exports.query = query;
 async function queryItems(keyCondition, key, args = {}) {
-    args = (0, client_1.withDefaults)(args, "queryItems");
+    args = (0, lib_1.withDefaults)(args, "queryItems");
     return _query(keyCondition, key, args).then((res) => (res?.Items || [])
-        .map((item) => item && (0, util_dynamodb_1.unmarshall)(item))
+        .map((item) => item && (0, lib_1.unmarshallWithOptions)(item))
         .filter((item) => item));
 }
 exports.queryItems = queryItems;
 async function queryAllItems(keyCondition, key, args = {}) {
-    args = (0, client_1.withDefaults)(args, "queryAllItems");
+    args = (0, lib_1.withDefaults)(args, "queryAllItems");
     let data = await _query(keyCondition, key, args);
     while (data.LastEvaluatedKey) {
         if (data.LastEvaluatedKey) {
@@ -47,7 +46,7 @@ async function queryAllItems(keyCondition, key, args = {}) {
         }
     }
     return (data?.Items || [])
-        .map((item) => item && (0, util_dynamodb_1.unmarshall)(item))
+        .map((item) => item && (0, lib_1.unmarshallWithOptions)(item))
         .filter((item) => item);
 }
 exports.queryAllItems = queryAllItems;

package/dist/operations/update.js

@@ -2,48 +2,46 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.removeAttributes = exports.updateItem = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
-const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
-const client_1 = require("../lib/client");
-const helpers_1 = require("../lib/helpers");
+const lib_1 = require("../lib");
 async function updateItem(key, data, args = {}) {
-    args = (0, client_1.withDefaults)(args, "updateItem");
+    args = (0, lib_1.withDefaults)(args, "updateItem");
     if (!Object.keys(data).includes("updatedAt")) {
         data.updatedAt = Date.now();
     }
-    const valuesInCondition = (0, helpers_1.getAttributesFromExpression)(args?.ConditionExpression || "", ":");
-    const namesInCondition = (0, helpers_1.getAttributesFromExpression)(args?.ConditionExpression || "");
+    const valuesInCondition = (0, lib_1.getAttributesFromExpression)(args?.ConditionExpression || "", ":");
+    const namesInCondition = (0, lib_1.getAttributesFromExpression)(args?.ConditionExpression || "");
     const attributesToUpdate = Object.keys(data).filter((key) => !valuesInCondition.includes(key));
     const UpdateExpression = "SET " + attributesToUpdate.map((key) => `#${key} = :${key}`).join(", ");
-    return client_1.client
+    return (0, lib_1.getClient)()
         .send(new client_dynamodb_1.UpdateItemCommand({
-        Key: (0, helpers_1.stripKey)(key, args),
+        Key: (0, lib_1.stripKey)(key, args),
         UpdateExpression,
-        ExpressionAttributeValues: (0, helpers_1.getAttributeValues)(data, [
+        ExpressionAttributeValues: (0, lib_1.getAttributeValues)(data, [
             ...attributesToUpdate,
             ...valuesInCondition,
         ]),
-        ExpressionAttributeNames: (0, helpers_1.getAttributeNames)(data, [
+        ExpressionAttributeNames: (0, lib_1.getAttributeNames)(data, [
             ...attributesToUpdate,
             ...namesInCondition,
         ]),
         ...args,
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }))
-        .then((res) => args?.ReturnValues ? (0, util_dynamodb_1.unmarshall)(res.Attributes) : undefined);
+        .then((res) => args?.ReturnValues ? (0, lib_1.unmarshallWithOptions)(res.Attributes) : undefined);
 }
 exports.updateItem = updateItem;
 async function removeAttributes(key, attributes, args = {}) {
-    args = (0, client_1.withDefaults)(args, "removeAttributes");
+    args = (0, lib_1.withDefaults)(args, "removeAttributes");
     const UpdateExpression = "REMOVE " + attributes.map((att) => `#${att}`).join(", ");
-    return client_1.client.send(new client_dynamodb_1.UpdateItemCommand({
-        Key: (0, helpers_1.stripKey)(key, args),
+    return (0, lib_1.getClient)().send(new client_dynamodb_1.UpdateItemCommand({
+        Key: (0, lib_1.stripKey)(key, args),
         UpdateExpression,
-        ExpressionAttributeNames: (0, helpers_1.getAttributeNames)(attributes.reduce((acc, att) => {
+        ExpressionAttributeNames: (0, lib_1.getAttributeNames)(attributes.reduce((acc, att) => {
             acc[att] = att;
             return acc;
         }, {})),
         ...args,
-        TableName: args?.TableName || (0, client_1.getDefaultTable)(),
+        TableName: args?.TableName || (0, lib_1.getDefaultTable)(),
     }));
 }
 exports.removeAttributes = removeAttributes;

package/package.json

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

package/readme.md

@@ -10,10 +10,11 @@ Contains convenience functions for all major dynamodb operations. Requires very
 - 🎁 Will **automatically marshall and unmarshall** items
 - 📦 Will **group items into batches** to avoid aws limits and improve performance
 - ⏱ Will **automatically** add `createdAt` and `updatedAt` attributes on all items to track their most recent create/update operation timestamp. Example value: `Date.now() -> 1685138436000`
-- 🔄 Will **retry** some operations (getItems, deleteItems) **up to 3 times** on unprocessed items
+- 🔄 Will **retry** `getItems`, `deleteItems` **up to 3 times** on unprocessed items and `queryAllItems` until finished
 - 🔒 When specifying an item using its keySchema, all additional attributes (apart from keySchema attributes from `initSchema` or `PK` & `SK` as default) will be removed to avoid errors
 - 👻 Will **use placeholders** to avoid colliding with [reserved words](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ReservedWords.html) if applicable
-- 🌎 Supports globally defined default arguments for each operation
+- 🌎 Supports globally defined default arguments for each operation ([example](#configuring-global-defaults))
+- 🔨 Supports fixes for several issues with dynamodb ([example](#applying-fixes))
 
 ## Installation
 
@@ -36,7 +37,7 @@ initSchema({
     range: "SK",
   },
   [process.env.SECOND_TABLE]: {
-    hash: "bookId",
+    hash: "somePK",
   },
 });
 ```
@@ -67,26 +68,6 @@ const item = await getItem(
 await deleteItem(item, { TableName: process.env.SECOND_TABLE });
 ```
 
-## Configuring global defaults
-
-Global defaults can be configured using the `initDefaults` function. This allows to provide but still override every property of the `args` parameter.
-
-Should be called before any DynamoDB operations are performed.
-
-```ts
-import { initDefaults } from "@moicky/dynamodb";
-
-// Enables consistent reads for all DynamoDB operations which support it.
-initDefaults({
-  getItem: { ConsistentRead: true },
-  getAllItems: { ConsistentRead: true },
-
-  query: { ConsistentRead: true },
-  queryItems: { ConsistentRead: true },
-  queryAllItems: { ConsistentRead: true },
-});
-```
-
 ## Usage Examples
 
 ### Put Items
@@ -275,6 +256,60 @@ const id4 = await getAscendingId({
 console.log(id4); // "00000010"
 ```
 
+## Configuring global defaults
+
+Global defaults can be configured using the `initDefaults` function. This allows to provide but still override every property of the `args` parameter.
+
+Should be called before any DynamoDB operations are performed.
+
+```ts
+import { initDefaultArguments } from "@moicky/dynamodb";
+
+// Enables consistent reads for all DynamoDB operations which support it.
+initDefaultArguments({
+  getItem: { ConsistentRead: true },
+  getAllItems: { ConsistentRead: true },
+
+  itemExists: { ConsistentRead: true },
+
+  query: { ConsistentRead: true },
+  queryItems: { ConsistentRead: true },
+  queryAllItems: { ConsistentRead: true },
+});
+```
+
+## Applying fixes
+
+Arguments which are passed to [marshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.marshallOptions.html) and [unmarshall](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/interfaces/_aws_sdk_util_dynamodb.unmarshallOptions.html) from `@aws-sdk/util-dynamodb` can be configured using
+
+```ts
+import { initFixes } from "@moicky/dynamodb";
+
+initFixes({
+  marshallOptions: {
+    removeUndefinedValues: true,
+  },
+  unmarshallOptions: {
+    wrapNumbers: true,
+  },
+});
+```
+
+When using `GlobalSecondaryIndexes`, DynamoDb does not support using `ConsistantRead`. This is fixed by default (`ConsistantRead` is turned off) and can be configured using:
+
+```ts
+import { initFixes } from "@moicky/dynamodb";
+
+initFixes({
+  disableConsistantReadWhenUsingIndexes: {
+    enabled: true, // default,
+
+    // Won't disable ConsistantRead if IndexName is specified here.
+    stillUseOnLocalIndexes: ["localIndexName1", "localIndexName1"],
+  },
+});
+```
+
 ## What are the benefits and why should I use it?
 
 Generally it makes it easier to interact with the dynamodb from AWS. Here are some before and after examples using the new aws-sdk v3: