ag-common 0.0.733 → 0.0.735

package/dist/api/helpers/aws.js

@@ -7,7 +7,7 @@ const ses_1 = require("./ses");
 const sqs_1 = require("./sqs");
 const setAwsRegion = (region) => {
     (0, dynamo_1.setDynamo)(region);
-    (0, s3_1.setS3)(region);
+    (0, s3_1.setS3)({ region, provider: 's3' });
     (0, ses_1.setSes)(region);
     (0, sqs_1.setSqs)(region);
 };

package/dist/api/helpers/dynamo/delete.d.ts

@@ -0,0 +1,13 @@
+import type { DynamoDBResult } from './types';
+export declare const batchDelete: (params: {
+    tableName: string;
+    keys: string[];
+    pkName: string;
+    opt?: {
+        /** default 20 */
+        batchSize?: number;
+        /** option to always retry on 429 until done. default false */
+        alwaysRetry?: boolean;
+    };
+}) => Promise<DynamoDBResult<void>>;
+export declare const wipeTable: (tableName: string) => Promise<DynamoDBResult<void>>;

package/dist/api/helpers/dynamo/delete.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wipeTable = exports.batchDelete = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const array_1 = require("../../../common/helpers/array");
+const async_1 = require("../../../common/helpers/async");
+const withRetry_1 = require("../withRetry");
+const _1 = require(".");
+const get_1 = require("./get");
+const batchDelete = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    try {
+        const { batchSize = 20, alwaysRetry = false } = (_a = params.opt) !== null && _a !== void 0 ? _a : {};
+        const chunked = (0, array_1.chunk)(params.keys, batchSize);
+        let processed = 0;
+        yield (0, async_1.asyncForEach)(chunked, (chunk) => __awaiter(void 0, void 0, void 0, function* () {
+            const command = new lib_dynamodb_1.BatchWriteCommand({
+                RequestItems: {
+                    [params.tableName]: chunk.map((key) => ({
+                        DeleteRequest: { Key: { [params.pkName]: key } },
+                    })),
+                },
+            });
+            yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(command), `batchdelete ${processed}/${params.keys.length}. size=${batchSize}`, {
+                maxRetries: alwaysRetry ? null : undefined,
+            });
+            processed += chunk.length;
+        }));
+        return { data: undefined };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.batchDelete = batchDelete;
+const wipeTable = (tableName) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, e_1, _b, _c;
+    try {
+        const generator = (0, get_1.scanWithGenerator)(tableName, {
+            BATCH_SIZE: 100, // Process in chunks of 100 items
+            alwaysRetry: true, // Always retry on 429 since we want to ensure complete deletion
+        });
+        try {
+            // Process each batch of items
+            for (var _d = true, generator_1 = __asyncValues(generator), generator_1_1; generator_1_1 = yield generator_1.next(), _a = generator_1_1.done, !_a; _d = true) {
+                _c = generator_1_1.value;
+                _d = false;
+                const batch = _c;
+                const pks = batch.map((item) => item.PK);
+                if (pks.length > 0) {
+                    const result = yield (0, exports.batchDelete)({
+                        tableName,
+                        keys: pks,
+                        pkName: 'PK',
+                        opt: {
+                            alwaysRetry: true, // Always retry on 429 since we want to ensure complete deletion
+                        },
+                    });
+                    if ('error' in result) {
+                        return result;
+                    }
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = generator_1.return)) yield _b.call(generator_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return { data: undefined };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.wipeTable = wipeTable;

package/dist/api/helpers/dynamo/get.d.ts

@@ -0,0 +1,30 @@
+import type { Key } from '../../types';
+import type { DynamoDBResult } from './types';
+import type { DynamoQueryParams, ScanOptions } from './types';
+export declare const getItemsDynamo: <T>(params: {
+    tableName: string;
+    items: {
+        pkName: string;
+        pkValue: string;
+    }[];
+}) => Promise<DynamoDBResult<T[]>>;
+export declare const getItemDynamo: <T>(params: {
+    tableName: string;
+    pkName: string;
+    pkValue: string;
+}) => Promise<DynamoDBResult<T>>;
+export declare const queryDynamo: <T>(params: DynamoQueryParams) => Promise<{
+    data: T[];
+    startKey?: Key;
+} | {
+    error: string;
+}>;
+export declare const scan: <T>(tableName: string, options?: ScanOptions) => Promise<DynamoDBResult<T[]>>;
+export declare function queryWithGenerator<T>(params: DynamoQueryParams & {
+    /** how many to return in query generator. default 100 */
+    BATCH_SIZE?: number;
+}): AsyncGenerator<T[], void, unknown>;
+export declare function scanWithGenerator<T>(tableName: string, options?: ScanOptions & {
+    /** how many to return in scan generator. default 100 */
+    BATCH_SIZE?: number;
+}): AsyncGenerator<T[], void, unknown>;

package/dist/api/helpers/dynamo/get.js

@@ -0,0 +1,229 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scan = exports.queryDynamo = exports.getItemDynamo = exports.getItemsDynamo = void 0;
+exports.queryWithGenerator = queryWithGenerator;
+exports.scanWithGenerator = scanWithGenerator;
+/* eslint-disable no-await-in-loop */
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const withRetry_1 = require("../withRetry");
+const _1 = require(".");
+const isError = (result) => 'error' in result;
+/**
+ * Helper function that builds the query parameters and executes the query
+ */
+const executeQuery = (params, startKey) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e;
+    let kce = `#${params.pkName.toLowerCase()} ${(_a = params.pkOperator) !== null && _a !== void 0 ? _a : '='} :${params.pkName.toLowerCase()}`;
+    const ean = {
+        [`#${params.pkName.toLowerCase()}`]: params.pkName,
+    };
+    const eav = {
+        [`:${params.pkName.toLowerCase()}`]: params.pkValue,
+    };
+    if (params.skName && params.skValue !== undefined) {
+        const { skName, skValue, skOperator = '=' } = params;
+        if (skOperator === 'BETWEEN' && Array.isArray(skValue)) {
+            const [start, end] = skValue;
+            kce += ` AND #${skName.toLowerCase()} BETWEEN :${skName}1 AND :${skName}2`;
+            ean[`#${skName.toLowerCase()}`] = skName;
+            eav[`:${skName}1`] = start;
+            eav[`:${skName}2`] = end;
+        }
+        else if (skOperator === 'BEGINS_WITH') {
+            kce += ` AND begins_with(#${skName.toLowerCase()}, :${skName.toLowerCase()})`;
+            ean[`#${skName.toLowerCase()}`] = skName;
+            eav[`:${skName.toLowerCase()}`] = skValue;
+        }
+        else {
+            kce += ` AND #${skName.toLowerCase()} ${skOperator} :${skName.toLowerCase()}`;
+            ean[`#${skName.toLowerCase()}`] = skName;
+            eav[`:${skName.toLowerCase()}`] = skValue;
+        }
+    }
+    const queryParams = new lib_dynamodb_1.QueryCommand(Object.assign({ TableName: params.tableName, KeyConditionExpression: kce, ExpressionAttributeNames: Object.assign(Object.assign({}, ean), (_b = params.filter) === null || _b === void 0 ? void 0 : _b.attrNames), ExpressionAttributeValues: Object.assign(Object.assign({}, eav), (_c = params.filter) === null || _c === void 0 ? void 0 : _c.attrValues), ScanIndexForward: (_d = params.sortAscending) !== null && _d !== void 0 ? _d : true, Limit: (_e = params.BATCH_SIZE) !== null && _e !== void 0 ? _e : params.limit, IndexName: params.indexName, ExclusiveStartKey: startKey }, (params.filter && Object.assign({ FilterExpression: params.filter.filterExpression }, (params.filter.attrValues && {
+        ExpressionAttributeValues: Object.assign(Object.assign({}, eav), params.filter.attrValues),
+    })))));
+    // eslint-disable-next-line no-return-await
+    return yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(queryParams), 'queryDynamo');
+});
+/**
+ * Helper function that builds the scan parameters and executes the scan
+ */
+const executeScan = (tableName, options, exclusiveStartKey) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const projectionAttrs = (_a = options === null || options === void 0 ? void 0 : options.requiredAttributeList) === null || _a === void 0 ? void 0 : _a.reduce((acc, attr, index) => {
+        acc[`#proj${index}`] = attr;
+        return acc;
+    }, {});
+    const expressionAttributeNames = Object.assign(Object.assign({}, projectionAttrs), (_b = options === null || options === void 0 ? void 0 : options.filter) === null || _b === void 0 ? void 0 : _b.attrNames);
+    const params = new lib_dynamodb_1.ScanCommand(Object.assign(Object.assign(Object.assign(Object.assign({ TableName: tableName, IndexName: options === null || options === void 0 ? void 0 : options.indexName, Limit: options === null || options === void 0 ? void 0 : options.BATCH_SIZE }, ((options === null || options === void 0 ? void 0 : options.filter) && Object.assign({ FilterExpression: options.filter.filterExpression }, (options.filter.attrValues && {
+        ExpressionAttributeValues: options.filter.attrValues,
+    })))), (Object.keys(expressionAttributeNames).length > 0 && {
+        ExpressionAttributeNames: expressionAttributeNames,
+    })), ((options === null || options === void 0 ? void 0 : options.requiredAttributeList) && {
+        ProjectionExpression: options.requiredAttributeList
+            .map((_, index) => `#proj${index}`)
+            .join(', '),
+    })), { ExclusiveStartKey: exclusiveStartKey }));
+    // eslint-disable-next-line no-return-await
+    return yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(params), `scan. already seen=${exclusiveStartKey ? 'some' : '0'} items`, {
+        maxRetries: (options === null || options === void 0 ? void 0 : options.alwaysRetry) ? null : undefined,
+    });
+});
+const getItemsDynamo = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    try {
+        const command = new lib_dynamodb_1.BatchGetCommand({
+            RequestItems: {
+                [params.tableName]: {
+                    Keys: params.items.map(({ pkName, pkValue }) => ({
+                        [pkName]: pkValue,
+                    })),
+                },
+            },
+        });
+        const result = yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(command), 'getItemsDynamo');
+        return {
+            data: (_b = (_a = result.Responses) === null || _a === void 0 ? void 0 : _a[params.tableName]) !== null && _b !== void 0 ? _b : [],
+        };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.getItemsDynamo = getItemsDynamo;
+const getItemDynamo = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield (0, exports.getItemsDynamo)({
+        tableName: params.tableName,
+        items: [{ pkName: params.pkName, pkValue: params.pkValue }],
+    });
+    if (isError(result)) {
+        return result;
+    }
+    return { data: result.data[0] };
+});
+exports.getItemDynamo = getItemDynamo;
+const queryDynamo = (params) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const items = [];
+        let startKey;
+        do {
+            const result = yield executeQuery(params, startKey);
+            if (result.Items) {
+                items.push(...result.Items);
+            }
+            startKey = result.LastEvaluatedKey;
+            if (params.limit && items.length >= params.limit) {
+                return {
+                    data: items.slice(0, params.limit),
+                    startKey,
+                };
+            }
+        } while (startKey && Object.keys(startKey).length > 0);
+        return { data: items };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.queryDynamo = queryDynamo;
+const scan = (tableName, options) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const Items = [];
+        let ExclusiveStartKey;
+        do {
+            const result = yield executeScan(tableName, options, ExclusiveStartKey);
+            if (result.Items) {
+                Items.push(...result.Items);
+            }
+            ExclusiveStartKey = result.LastEvaluatedKey;
+        } while (ExclusiveStartKey);
+        return { data: Items };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.scan = scan;
+function queryWithGenerator(params) {
+    return __asyncGenerator(this, arguments, function* queryWithGenerator_1() {
+        var _a;
+        const BATCH_SIZE = (_a = params.BATCH_SIZE) !== null && _a !== void 0 ? _a : 100;
+        let items = [];
+        let startKey;
+        try {
+            do {
+                const result = yield __await(executeQuery(params, startKey));
+                if (result.Items) {
+                    items.push(...result.Items);
+                    // Process items in chunks of BATCH_SIZE
+                    while (items.length >= BATCH_SIZE) {
+                        const batch = items.slice(0, BATCH_SIZE);
+                        items = items.slice(BATCH_SIZE);
+                        yield yield __await(batch);
+                    }
+                }
+                startKey = result.LastEvaluatedKey;
+            } while (startKey && Object.keys(startKey).length > 0);
+            // Yield any remaining items
+            if (items.length > 0) {
+                yield yield __await(items);
+            }
+        }
+        catch (e) {
+            throw new Error(`Query generator error: ${e.toString()}`);
+        }
+    });
+}
+function scanWithGenerator(tableName, options) {
+    return __asyncGenerator(this, arguments, function* scanWithGenerator_1() {
+        var _a;
+        const BATCH_SIZE = (_a = options === null || options === void 0 ? void 0 : options.BATCH_SIZE) !== null && _a !== void 0 ? _a : 100;
+        let items = [];
+        let exclusiveStartKey;
+        try {
+            do {
+                const result = yield __await(executeScan(tableName, options, exclusiveStartKey));
+                if (result.Items) {
+                    items.push(...result.Items);
+                    // Process items in chunks of BATCH_SIZE
+                    while (items.length >= BATCH_SIZE) {
+                        const batch = items.slice(0, BATCH_SIZE);
+                        items = items.slice(BATCH_SIZE);
+                        yield yield __await(batch);
+                    }
+                }
+                exclusiveStartKey = result.LastEvaluatedKey;
+            } while (exclusiveStartKey);
+            // Yield any remaining items
+            if (items.length > 0) {
+                yield yield __await(items);
+            }
+        }
+        catch (e) {
+            throw new Error(`Scan generator error: ${e.toString()}`);
+        }
+    });
+}

package/dist/api/helpers/dynamo/index.d.ts

@@ -0,0 +1,50 @@
+import { DynamoDBDocument } from '@aws-sdk/lib-dynamodb';
+import type { AwsCredentialIdentity } from '@smithy/types';
+import * as getOps from './get';
+export declare let dynamoDb: DynamoDBDocument;
+/**
+ * Sets up the DynamoDB client with the specified region and credentials.
+ * @param region - AWS region to connect to
+ * @param credentials - Optional AWS credentials
+ * @returns Configured DynamoDBDocument client
+ */
+export declare const setDynamo: (region: string, credentials?: AwsCredentialIdentity) => DynamoDBDocument;
+export declare const getItemDynamo: <T>(params: {
+    tableName: string;
+    pkName: string;
+    pkValue: string;
+}) => Promise<import("./types").DynamoDBResult<T>>, getItemsDynamo: <T>(params: {
+    tableName: string;
+    items: {
+        pkName: string;
+        pkValue: string;
+    }[];
+}) => Promise<import("./types").DynamoDBResult<T[]>>, queryDynamo: <T>(params: import("./types").DynamoQueryParams) => Promise<{
+    data: T[];
+    startKey?: import("../..").Key;
+} | {
+    error: string;
+}>, queryWithGenerator: typeof getOps.queryWithGenerator, scan: <T>(tableName: string, options?: import("./types").ScanOptions) => Promise<import("./types").DynamoDBResult<T[]>>, scanWithGenerator: typeof getOps.scanWithGenerator;
+export declare const putDynamo: <T extends Record<string, unknown>>(item: T, tableName: string, opt?: {
+    pkName?: string;
+}) => Promise<import("./types").DynamoDBResult<void>>, batchWrite: <T extends Record<string, unknown>>(tableName: string, items: T[], opt?: {
+    alwaysRetry?: boolean;
+    batchSize?: number;
+}) => Promise<import("./types").DynamoDBResult<void>>, getDynamoUpdates: <T extends Record<string, unknown>>(item: T, options?: {
+    excludeKeys?: string[];
+}) => {
+    UpdateExpression: string;
+    ExpressionAttributeNames: Record<string, string>;
+    ExpressionAttributeValues: Record<string, unknown>;
+    ReturnValues: "UPDATED_NEW";
+};
+export declare const batchDelete: (params: {
+    tableName: string;
+    keys: string[];
+    pkName: string;
+    opt?: {
+        batchSize?: number;
+        alwaysRetry?: boolean;
+    };
+}) => Promise<import("./types").DynamoDBResult<void>>, wipeTable: (tableName: string) => Promise<import("./types").DynamoDBResult<void>>;
+export * from './types';

package/dist/api/helpers/dynamo/index.js

@@ -0,0 +1,66 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+exports.wipeTable = exports.batchDelete = exports.getDynamoUpdates = exports.batchWrite = exports.putDynamo = exports.scanWithGenerator = exports.scan = exports.queryWithGenerator = exports.queryDynamo = exports.getItemsDynamo = exports.getItemDynamo = exports.setDynamo = exports.dynamoDb = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const deleteOps = __importStar(require("./delete"));
+const getOps = __importStar(require("./get"));
+const setOps = __importStar(require("./set"));
+/**
+ * Sets up the DynamoDB client with the specified region and credentials.
+ * @param region - AWS region to connect to
+ * @param credentials - Optional AWS credentials
+ * @returns Configured DynamoDBDocument client
+ */
+const setDynamo = (region, credentials) => {
+    const client = new client_dynamodb_1.DynamoDBClient({ region, credentials });
+    exports.dynamoDb = lib_dynamodb_1.DynamoDBDocument.from(client, {
+        marshallOptions: { removeUndefinedValues: true },
+    });
+    return exports.dynamoDb;
+};
+exports.setDynamo = setDynamo;
+// Initialize with default region
+exports.dynamoDb = (0, exports.setDynamo)('ap-southeast-2');
+// Export all operations
+exports.getItemDynamo = getOps.getItemDynamo, exports.getItemsDynamo = getOps.getItemsDynamo, exports.queryDynamo = getOps.queryDynamo, exports.queryWithGenerator = getOps.queryWithGenerator, exports.scan = getOps.scan, exports.scanWithGenerator = getOps.scanWithGenerator;
+exports.putDynamo = setOps.putDynamo, exports.batchWrite = setOps.batchWrite, exports.getDynamoUpdates = setOps.getDynamoUpdates;
+exports.batchDelete = deleteOps.batchDelete, exports.wipeTable = deleteOps.wipeTable;
+// Export types
+__exportStar(require("./types"), exports);

package/dist/api/helpers/dynamo/set.d.ts

@@ -0,0 +1,18 @@
+import type { DynamoDBResult } from './types';
+export declare const putDynamo: <T extends Record<string, unknown>>(item: T, tableName: string, opt?: {
+    pkName?: string;
+}) => Promise<DynamoDBResult<void>>;
+export declare const batchWrite: <T extends Record<string, unknown>>(tableName: string, items: T[], opt?: {
+    /** option to always retry on 429 until done */
+    alwaysRetry?: boolean;
+    /** default 20 */
+    batchSize?: number;
+}) => Promise<DynamoDBResult<void>>;
+export declare const getDynamoUpdates: <T extends Record<string, unknown>>(item: T, options?: {
+    excludeKeys?: string[];
+}) => {
+    UpdateExpression: string;
+    ExpressionAttributeNames: Record<string, string>;
+    ExpressionAttributeValues: Record<string, unknown>;
+    ReturnValues: "UPDATED_NEW";
+};

package/dist/api/helpers/dynamo/set.js

@@ -0,0 +1,72 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDynamoUpdates = exports.batchWrite = exports.putDynamo = void 0;
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+const array_1 = require("../../../common/helpers/array");
+const async_1 = require("../../../common/helpers/async");
+const withRetry_1 = require("../withRetry");
+const _1 = require(".");
+const putDynamo = (item, tableName, opt) => __awaiter(void 0, void 0, void 0, function* () {
+    const params = new lib_dynamodb_1.PutCommand(Object.assign({ TableName: tableName, Item: item }, ((opt === null || opt === void 0 ? void 0 : opt.pkName) && {
+        ConditionExpression: `attribute_not_exists(${opt.pkName})`,
+    })));
+    try {
+        yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(params), 'putDynamo');
+        return { data: undefined };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.putDynamo = putDynamo;
+const batchWrite = (tableName, items, opt) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { batchSize = 20 } = opt !== null && opt !== void 0 ? opt : {};
+        let processed = 0;
+        const chunked = (0, array_1.chunk)(items, batchSize);
+        yield (0, async_1.asyncForEach)(chunked, (chunk) => __awaiter(void 0, void 0, void 0, function* () {
+            const params = new lib_dynamodb_1.BatchWriteCommand({
+                RequestItems: {
+                    [tableName]: chunk.map((Item) => ({ PutRequest: { Item } })),
+                },
+            });
+            yield (0, withRetry_1.withRetry)(() => _1.dynamoDb.send(params), `batchwrite ${processed}/${items.length}. size=${batchSize}`, {
+                maxRetries: (opt === null || opt === void 0 ? void 0 : opt.alwaysRetry) ? null : undefined,
+            });
+            processed += chunk.length;
+        }));
+        return { data: undefined };
+    }
+    catch (e) {
+        return { error: e.toString() };
+    }
+});
+exports.batchWrite = batchWrite;
+const getDynamoUpdates = (item, options) => {
+    var _a;
+    const excludeKeys = ((_a = options === null || options === void 0 ? void 0 : options.excludeKeys) !== null && _a !== void 0 ? _a : ['PK']).map((k) => k.toLowerCase());
+    const validEntries = Object.entries(item).filter(([key, value]) => !excludeKeys.includes(key.toLowerCase()) && value != null);
+    const ExpressionAttributeNames = {};
+    const ExpressionAttributeValues = {};
+    const UpdateExpression = validEntries.reduce((expr, [key, value], index) => {
+        ExpressionAttributeNames[`#${key}`] = key;
+        ExpressionAttributeValues[`:${key}`] = value;
+        return `${expr}${index > 0 ? ', ' : ''}#${key} = :${key}`;
+    }, 'SET ');
+    return {
+        UpdateExpression,
+        ExpressionAttributeNames,
+        ExpressionAttributeValues,
+        ReturnValues: 'UPDATED_NEW',
+    };
+};
+exports.getDynamoUpdates = getDynamoUpdates;

package/dist/api/helpers/dynamo/types.d.ts

@@ -0,0 +1,43 @@
+import type { Key } from '../../types';
+export type DynamoDBError = {
+    error: string;
+};
+export type DynamoDBSuccess<T> = {
+    data: T;
+};
+export type DynamoDBResult<T> = DynamoDBSuccess<T> | DynamoDBError;
+export interface DynamoFilter {
+    filterExpression: string;
+    attrNames: Record<string, string>;
+    attrValues?: Record<string, unknown>;
+}
+export interface ScanOptions {
+    /** eg
+     * filter: {
+        filterExpression: '#feedIcon = :empty',
+        attrNames: { '#feedIcon': 'feedIcon' },
+        attrValues: {
+          ':empty': '',
+        },
+      },
+     */
+    filter?: DynamoFilter;
+    requiredAttributeList?: string[];
+    indexName?: string;
+    alwaysRetry?: boolean;
+}
+export interface DynamoQueryParams {
+    tableName: string;
+    pkName: string;
+    pkValue: string | number;
+    pkOperator?: '=' | '<' | '>' | '<=' | '>=';
+    skName?: string;
+    skValue?: string | number | [string | number, string | number];
+    skOperator?: '=' | '<' | '>' | '<=' | '>=' | 'BETWEEN' | 'BEGINS_WITH';
+    indexName?: string;
+    limit?: number;
+    startKey?: Key;
+    filter?: DynamoFilter;
+    sortAscending?: boolean;
+}
+export declare const isError: <T>(result: DynamoDBResult<T>) => result is DynamoDBError;

package/dist/api/helpers/dynamo/types.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isError = void 0;
+const isError = (result) => 'error' in result;
+exports.isError = isError;

package/dist/api/helpers/s3.d.ts

@@ -1,7 +1,15 @@
 import { S3Client } from '@aws-sdk/client-s3';
 import type { StreamingBlobPayloadOutputTypes } from '@smithy/types';
 import type { Buffer } from 'buffer';
-export declare const setS3: (region: string) => S3Client;
+export type StorageProvider = 's3' | 'r2';
+export interface StorageConfig {
+    provider: StorageProvider;
+    region: string;
+    endpoint?: string;
+    accountId?: string;
+}
+export declare const createStorageClient: (config: StorageConfig) => S3Client;
+export declare const setS3: (config: StorageConfig) => S3Client;
 export declare const s3: S3Client;
 export declare const getS3Object: ({ fileurl: { Bucket, Key }, }: {
     fileurl: {