@lafken/dynamo 0.10.1

package/lib/resolver/table/internal/internal.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalTable = void 0;
+const data_aws_cloudwatch_event_bus_1 = require("@cdktn/provider-aws/lib/data-aws-cloudwatch-event-bus");
+const dynamodb_table_1 = require("@cdktn/provider-aws/lib/dynamodb-table");
+const pipes_pipe_1 = require("@cdktn/provider-aws/lib/pipes-pipe");
+const resolver_1 = require("@lafken/resolver");
+const service_1 = require("../../../service");
+const mapFieldType = {
+    String: 'S',
+    Number: 'N',
+};
+class InternalTable extends resolver_1.lafkenResource.make(dynamodb_table_1.DynamodbTable) {
+    constructor(scope, props) {
+        const { modelProps, partitionKey: partitionKeyName, sortKey: sortKeyName, fields, } = (0, service_1.getModelInformation)(props.classResource);
+        const { globalIndexes, localIndexes, indexAttributes } = InternalTable.getIndexes(scope, modelProps.indexes, sortKeyName);
+        const availableAttributes = new Set([...(indexAttributes || new Set())]);
+        availableAttributes.add(partitionKeyName.toString());
+        if (sortKeyName) {
+            availableAttributes.add(sortKeyName.toString());
+        }
+        super(scope, `${modelProps.name}-table`, {
+            name: modelProps.name,
+            rangeKey: sortKeyName,
+            hashKey: partitionKeyName,
+            attribute: InternalTable.getAttributes(fields, availableAttributes, modelProps.ttl),
+            globalSecondaryIndex: globalIndexes,
+            localSecondaryIndex: localIndexes,
+            streamEnabled: !!modelProps.stream?.enabled,
+            streamViewType: modelProps.stream?.enabled
+                ? modelProps.stream?.type || 'NEW_AND_OLD_IMAGES'
+                : undefined,
+            ttl: modelProps.ttl
+                ? {
+                    attributeName: modelProps.ttl.toString(),
+                    enabled: true,
+                }
+                : undefined,
+            ...InternalTable.getBillingModeProps(modelProps),
+            replica: modelProps.replica,
+        });
+        this.isGlobal('dynamo', modelProps.name);
+        if (modelProps.stream?.enabled) {
+            const defaultBus = new data_aws_cloudwatch_event_bus_1.DataAwsCloudwatchEventBus(this, 'DefaultBus', {
+                name: 'default',
+            });
+            const role = new resolver_1.Role(this, `pipe-dynamo-${modelProps.name}-role`, {
+                services: [
+                    {
+                        type: 'dynamodb',
+                        permissions: [
+                            'DescribeStream',
+                            'GetRecords',
+                            'GetShardIterator',
+                            'ListStreams',
+                        ],
+                        resources: [this.streamArn],
+                    },
+                    {
+                        type: 'event',
+                        permissions: ['PutEvents'],
+                        resources: [defaultBus.arn],
+                    },
+                ],
+                name: `pipe-dynamo-${modelProps.name}-role`,
+                principal: 'pipes.amazonaws.com',
+            });
+            const filters = this.createFilterCriteria(modelProps.stream, fields);
+            new pipes_pipe_1.PipesPipe(this, `${modelProps.name}-pipe`, {
+                name: `${modelProps.name}-pipe`,
+                roleArn: role.arn,
+                source: this.streamArn,
+                target: defaultBus.arn,
+                desiredState: 'RUNNING',
+                sourceParameters: {
+                    dynamodbStreamParameters: {
+                        startingPosition: 'LATEST',
+                        batchSize: modelProps.stream.batchSize || 10,
+                        maximumBatchingWindowInSeconds: modelProps.stream.maximumBatchingWindowInSeconds || 1,
+                        maximumRecordAgeInSeconds: -1,
+                    },
+                    filterCriteria: filters.length
+                        ? { filter: filters.map((f) => ({ pattern: f.pattern })) }
+                        : undefined,
+                },
+                targetParameters: {
+                    eventbridgeEventBusParameters: {
+                        detailType: 'db:stream',
+                        source: `dynamodb.${modelProps.name}`,
+                    },
+                },
+            });
+        }
+        new resolver_1.ResourceOutput(this, modelProps.outputs);
+    }
+    static getAttributes(fields, indexAttributes, ttl) {
+        const attributes = [];
+        for (const key in fields) {
+            const field = fields[key];
+            const parsedType = mapFieldType[field.type];
+            if (!parsedType || !indexAttributes.has(field.name) || field.name === ttl) {
+                continue;
+            }
+            attributes.push({
+                name: field.name,
+                type: parsedType,
+            });
+        }
+        return attributes;
+    }
+    static getBillingModeProps(model) {
+        if (model.billingMode === 'provisioned') {
+            return {
+                billingModel: 'PROVISIONED',
+                readCapacity: model.readCapacity,
+                writeCapacity: model.writeCapacity,
+            };
+        }
+        if (model.billingMode === undefined || model.billingMode === 'pay_per_request') {
+            return {
+                billingMode: 'PAY_PER_REQUEST',
+            };
+        }
+    }
+    static getIndexes(scope, indexes = [], sortKeyName) {
+        if (indexes.length === 0) {
+            return {};
+        }
+        const indexAttributes = new Set([]);
+        const globalIndexes = [];
+        const localIndexes = [];
+        for (const index of indexes) {
+            const projectionType = 'ALL';
+            let nonKeyAttributes;
+            if (Array.isArray(index.projection)) {
+                nonKeyAttributes = index.projection;
+            }
+            if (index.type === 'local') {
+                if (!sortKeyName) {
+                    throw new Error('It is not possible to add a local secondary index without an associated sort key.');
+                }
+                indexAttributes.add(index.sortKey.toString());
+                localIndexes.push({
+                    name: index.name,
+                    rangeKey: index.sortKey.toString(),
+                    projectionType,
+                    nonKeyAttributes,
+                });
+                continue;
+            }
+            indexAttributes.add(index.partitionKey.toString());
+            if (index.sortKey) {
+                indexAttributes.add(index.sortKey.toString());
+            }
+            globalIndexes.push({
+                name: index.name,
+                hashKey: index.partitionKey.toString(),
+                rangeKey: index.sortKey ? index.sortKey.toString() : undefined,
+                projectionType,
+                nonKeyAttributes,
+                readCapacity: index.readCapacity,
+                writeCapacity: index.writeCapacity,
+            });
+        }
+        return {
+            indexAttributes,
+            localIndexes,
+            globalIndexes,
+        };
+    }
+    createFilterCriteria(stream, fields) {
+        const filters = [];
+        if (!stream.filters)
+            return [];
+        if (stream.filters.eventName) {
+            filters.push({ pattern: JSON.stringify({ eventName: stream.filters.eventName }) });
+        }
+        if (stream.filters.keys) {
+            filters.push({
+                pattern: JSON.stringify({
+                    dynamodb: {
+                        Keys: this.getKeyFilterCriteria(stream.filters.keys, fields),
+                    },
+                }),
+            });
+        }
+        if (stream.filters.newImage) {
+            filters.push({
+                pattern: JSON.stringify({
+                    dynamodb: {
+                        NewImage: this.getKeyFilterCriteria(stream.filters.newImage, fields),
+                    },
+                }),
+            });
+        }
+        if (stream.filters.oldImage) {
+            filters.push({
+                pattern: JSON.stringify({
+                    dynamodb: {
+                        OldImage: this.getKeyFilterCriteria(stream.filters.oldImage, fields),
+                    },
+                }),
+            });
+        }
+        return filters;
+    }
+    getKeyFilterCriteria(keys, fields) {
+        return Object.entries(keys).reduce((acc, [key, value]) => {
+            const field = fields[key];
+            if (!field) {
+                throw new Error(`field ${key} not found in dynamo table`);
+            }
+            const fieldType = mapFieldType[field.type];
+            if (!fieldType) {
+                throw new Error(`field ${key} has not valid type in filter criteria`);
+            }
+            acc[key] = {
+                [fieldType]: value,
+            };
+            return acc;
+        }, {});
+    }
+}
+exports.InternalTable = InternalTable;

package/lib/resolver/table/table.types.d.ts

@@ -0,0 +1,4 @@
+import type { ClassResource } from '@lafken/common';
+export interface InternalTableProps {
+    classResource: ClassResource;
+}

package/lib/resolver/table/table.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/client/client.d.ts

@@ -0,0 +1,3 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+export declare const client: DynamoDBClient;
+export declare const getClientWithXRay: () => DynamoDBClient;

package/lib/service/client/client.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getClientWithXRay = exports.client = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const aws_xray_sdk_1 = require("aws-xray-sdk");
+exports.client = new client_dynamodb_1.DynamoDBClient();
+const getClientWithXRay = () => {
+    return (0, aws_xray_sdk_1.captureAWSv3Client)(exports.client);
+};
+exports.getClientWithXRay = getClientWithXRay;

package/lib/service/index.d.ts

@@ -0,0 +1,3 @@
+export * from './query-builder';
+export * from './repository';
+export * from './transaction';

package/lib/service/index.js

@@ -0,0 +1,19 @@
+"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("./query-builder"), exports);
+__exportStar(require("./repository"), exports);
+__exportStar(require("./transaction"), exports);

package/lib/service/query-builder/base/base.d.ts

@@ -0,0 +1,19 @@
+import type { ClassResource } from '@lafken/common';
+import type { LocalIndex } from '../../../main';
+import type { GlobalIndexProperty } from '../dynamo-index/dynamo-index.types';
+import type { AndFilter, Filter, KeyCondition, OrFilter } from '../query-builder.types';
+import type { QueryBuilderProps } from './base.types';
+export declare class QueryBuilderBase<E extends ClassResource> {
+    private options;
+    constructor(options: QueryBuilderProps<E>);
+    protected attributeNames: Record<string, string>;
+    protected attributeValues: Record<string, any>;
+    protected getKeyConditionExpression(expression: KeyCondition<E>, index?: LocalIndex<E> | GlobalIndexProperty): string;
+    protected getFilterExpression<T>(filter: Filter<T> | OrFilter<T> | AndFilter<T>, names?: string[], union?: 'or' | 'and', counter?: number): string;
+    protected getAttributesAndNames(): {
+        ExpressionAttributeNames: Record<string, string> | undefined;
+        ExpressionAttributeValues: Record<string, import("@aws-sdk/client-dynamodb").AttributeValue> | undefined;
+    };
+    private resolveFilter;
+    private validateGlobalKey;
+}

package/lib/service/query-builder/base/base.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryBuilderBase = void 0;
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const base_utils_1 = require("./base.utils");
+class QueryBuilderBase {
+    options;
+    // biome-ignore lint/correctness/noUnusedPrivateClassMembers: ''
+    constructor(options) {
+        this.options = options;
+    }
+    attributeNames = {};
+    attributeValues = {};
+    getKeyConditionExpression(expression, index) {
+        const { partition, sort } = expression;
+        const isGlobalIndex = index?.type === 'global';
+        this.validateGlobalKey(Object.keys(partition), isGlobalIndex);
+        sort && this.validateGlobalKey(Object.keys(sort), isGlobalIndex);
+        const partitionFilters = [];
+        for (const key in partition) {
+            partitionFilters.push(this.resolveFilter({
+                expressionName: key,
+                value: partition[key],
+                filterExpressionKey: 'equal',
+            }));
+        }
+        if (!sort) {
+            return partitionFilters.join(' and ');
+        }
+        let sortValues = sort;
+        if (isGlobalIndex) {
+            let sortCount = Object.keys(sort).length;
+            sortValues = {};
+            let lastOmittedAttribute;
+            for (const attribute of index.sortKey) {
+                const attributeName = attribute;
+                if (sort[attributeName]) {
+                    if (lastOmittedAttribute) {
+                        throw new Error(`The sortKey is read from left to right. It is not possible to skip values; you must include the attribute"${lastOmittedAttribute}". Check the index "${index.name}"`);
+                    }
+                    if (sortCount > 1 && typeof sort[attributeName] === 'object') {
+                        throw new Error('Only the last attribute in the index sortKey can add a value different from the equal.');
+                    }
+                    sortValues[attributeName] = sort[attributeName];
+                    sortCount--;
+                    continue;
+                }
+                lastOmittedAttribute = attribute;
+            }
+        }
+        for (const key in sortValues) {
+            let filterExpressionKey = 'equal';
+            let sortValue = sort[key];
+            if (typeof sortValue === 'object') {
+                filterExpressionKey = Object.keys(sortValue || {})[0];
+                sortValue = sortValue[filterExpressionKey];
+            }
+            partitionFilters.push(this.resolveFilter({
+                expressionName: key,
+                value: sortValue,
+                filterExpressionKey,
+            }));
+        }
+        return partitionFilters.join(' and ');
+    }
+    getFilterExpression(filter, names = [], union = 'and', counter = 0) {
+        counter += 1;
+        const filterExpression = [];
+        let index = 0;
+        for (const key in filter) {
+            switch (key) {
+                case 'OR': {
+                    const orFilter = filter;
+                    const orExpressions = [];
+                    for (const condition of orFilter.OR) {
+                        const expression = this.getFilterExpression(condition, names, 'and', counter);
+                        counter += 1;
+                        orExpressions.push(expression);
+                    }
+                    filterExpression.push(`(${orExpressions.join(' or ')})`);
+                    break;
+                }
+                case 'AND': {
+                    const andFilter = filter;
+                    const expression = this.getFilterExpression(andFilter.AND, names, 'and', counter);
+                    filterExpression.join(`(${expression})`);
+                    break;
+                }
+                default: {
+                    const currentKeyNames = [...names, key];
+                    const keyName = currentKeyNames.join('.#');
+                    const keyValue = `${currentKeyNames.join('_')}_${counter}_${index}`;
+                    const keyFilter = filter[key];
+                    if (typeof keyFilter === 'object') {
+                        const keys = Object.keys(keyFilter || {});
+                        const filterResolver = keys.find((key) => base_utils_1.filterKeys.has(key));
+                        if (filterResolver) {
+                            const expression = this.resolveFilter({
+                                expressionName: keyName,
+                                keyName: key,
+                                filterExpressionKey: filterResolver,
+                                expressionValue: keyValue,
+                                value: keyFilter[filterResolver],
+                            });
+                            filterExpression.push(expression);
+                            break;
+                        }
+                        this.attributeNames[`#${key}`] = key;
+                        const expression = this.getFilterExpression(keyFilter, currentKeyNames, union);
+                        filterExpression.push(expression);
+                        break;
+                    }
+                    const expression = this.resolveFilter({
+                        expressionName: keyName,
+                        keyName: key,
+                        filterExpressionKey: 'equal',
+                        expressionValue: keyValue,
+                        value: keyFilter,
+                    });
+                    filterExpression.push(expression);
+                }
+            }
+            index++;
+        }
+        return `(${filterExpression.join(` ${union} `)})`;
+    }
+    getAttributesAndNames() {
+        return {
+            ExpressionAttributeNames: Object.keys(this.attributeNames).length > 0 ? this.attributeNames : undefined,
+            ExpressionAttributeValues: Object.keys(this.attributeValues).length > 0
+                ? (0, util_dynamodb_1.marshall)(this.attributeValues)
+                : undefined,
+        };
+    }
+    resolveFilter = ({ expressionName, filterExpressionKey, expressionValue, value, keyName = expressionName, }) => {
+        const name = `#${expressionName}`;
+        const { attributeValues, expression } = base_utils_1.filterResolver[filterExpressionKey](name, expressionValue || expressionName, value);
+        this.attributeNames[`#${keyName}`] = keyName;
+        this.attributeValues = {
+            ...this.attributeValues,
+            ...attributeValues,
+        };
+        return expression;
+    };
+    validateGlobalKey(keys, isGlobalIndex) {
+        if (keys.length > 1 && !isGlobalIndex) {
+            throw new Error('partition keys only support multi-attributes when they are a global multi-attribute index.');
+        }
+    }
+}
+exports.QueryBuilderBase = QueryBuilderBase;

package/lib/service/query-builder/base/base.types.d.ts

@@ -0,0 +1,37 @@
+import type { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import type { ModelInformation } from '../query-builder.types';
+import type { filterResolver } from './base.utils';
+export interface QueryBuilderProps<E extends ClassResource> extends ModelInformation<E> {
+    client: DynamoDBClient;
+}
+export type FilterResolverTypes = keyof typeof filterResolver;
+export interface ResolveFilterProps {
+    /**
+     * value without #
+     */
+    expressionName: string;
+    /**
+     * value of expression name
+     *
+     * @default {expressionName}
+     */
+    /**
+     * name used to attribute name
+     *
+     * @default {expressionName} with '#'
+     */
+    keyName?: string;
+    /**
+     * value of expression without :
+     */
+    expressionValue?: string;
+    /**
+     * value of expressionValue
+     */
+    value: any;
+    /**
+     * key of executed function
+     */
+    filterExpressionKey: FilterResolverTypes;
+}

package/lib/service/query-builder/base/base.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/query-builder/base/base.utils.d.ts

@@ -0,0 +1,22 @@
+export interface ExpressionResolverResult {
+    expression: string;
+    attributeValues: Record<string, any>;
+}
+export declare const expressionResolver: <V>(key: string, valueName: V, sign: string, value: any) => ExpressionResolverResult;
+export declare const filterResolver: {
+    equal: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    lessThan: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    lessOrEqualThan: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    greaterThan: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    greaterOrEqualThan: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    between: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    beginsWith: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    contains: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    exist: (key: string) => ExpressionResolverResult;
+    notExist: (key: string) => ExpressionResolverResult;
+    notEqual: (key: string, valueName: string, value: any) => ExpressionResolverResult;
+    in: (key: string, valueName: any, values: any[]) => ExpressionResolverResult;
+    notContains(key: string, valueName: string, value: any): ExpressionResolverResult;
+};
+export declare const notValueKeys: Set<"lessThan" | "lessOrEqualThan" | "greaterThan" | "greaterOrEqualThan" | "between" | "exist" | "notExist" | "contains" | "notContains" | "notEqual" | "in" | "beginsWith" | "equal">;
+export declare const filterKeys: Set<string>;

package/lib/service/query-builder/base/base.utils.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterKeys = exports.notValueKeys = exports.filterResolver = exports.expressionResolver = void 0;
+const expressionResolver = (key, valueName, sign, value) => {
+    const valueResolver = `:${valueName}`;
+    return {
+        expression: `${key} ${sign} ${valueResolver}`,
+        attributeValues: {
+            [valueResolver]: value,
+        },
+    };
+};
+exports.expressionResolver = expressionResolver;
+exports.filterResolver = {
+    equal: (key, valueName, value) => {
+        return (0, exports.expressionResolver)(key, valueName, '=', value);
+    },
+    lessThan: (key, valueName, value) => {
+        return (0, exports.expressionResolver)(key, valueName, '<', value);
+    },
+    lessOrEqualThan: (key, valueName, value) => {
+        return (0, exports.expressionResolver)(key, valueName, '<=', value);
+    },
+    greaterThan: (key, valueName, value) => {
+        return (0, exports.expressionResolver)(key, valueName, '>', value);
+    },
+    greaterOrEqualThan: (key, valueName, value) => {
+        return (0, exports.expressionResolver)(key, valueName, '>=', value);
+    },
+    between: (key, valueName, value) => {
+        return {
+            expression: `${key} BETWEEN :${valueName}_0 and :${valueName}_1`,
+            attributeValues: {
+                [`:${valueName}_0`]: value[0],
+                [`:${valueName}_1`]: value[1],
+            },
+        };
+    },
+    beginsWith: (key, valueName, value) => {
+        const valueResolver = `:${valueName}`;
+        return {
+            expression: `begins_with(${key}, ${valueResolver})`,
+            attributeValues: {
+                [valueResolver]: value,
+            },
+        };
+    },
+    contains: (key, valueName, value) => {
+        const valueResolver = `:${valueName}`;
+        return {
+            expression: `contains(${key}, ${valueResolver})`,
+            attributeValues: {
+                [valueResolver]: value,
+            },
+        };
+    },
+    exist: (key) => {
+        return {
+            expression: `attribute_exists(${key})`,
+            attributeValues: {},
+        };
+    },
+    notExist: (key) => {
+        return {
+            expression: `attribute_not_exists(${key})`,
+            attributeValues: {},
+        };
+    },
+    notEqual: (key, valueName, value) => {
+        return (0, exports.expressionResolver)(key, valueName, '<>', value);
+    },
+    in: (key, valueName, values) => {
+        const valueResolvers = values.map((_, index) => `:${valueName}_${index}`);
+        return {
+            expression: `${key} in (${valueResolvers.join(',')})`,
+            attributeValues: valueResolvers.reduce((acc, valueResolver, index) => {
+                acc[valueResolver] = values[index];
+                return acc;
+            }, {}),
+        };
+    },
+    notContains(key, valueName, value) {
+        const data = this.contains(key, valueName, value);
+        data.expression = `not ${data.expression}`;
+        return data;
+    },
+};
+exports.notValueKeys = new Set(['exist', 'notExist']);
+exports.filterKeys = new Set([...Object.keys(exports.filterResolver)]);

package/lib/service/query-builder/batch-write/batch-write.d.ts

@@ -0,0 +1,15 @@
+import { type BatchWriteItemCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import { QueryBuilderBase } from '../base/base';
+import type { BatchWriteBuilderProps } from './batch-write.types';
+export declare class BatchWriteBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    private queryOptions;
+    private commands;
+    constructor(queryOptions: BatchWriteBuilderProps<E>);
+    getCommand(): BatchWriteItemCommandInput[];
+    then<T>(resolve: (value: void[]) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+    private execAndRetry;
+    protected chunkItems<T>(items: Partial<T>[], size: number): Partial<T>[][];
+    private prepare;
+}

package/lib/service/query-builder/batch-write/batch-write.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchWriteBuilder = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const base_1 = require("../base/base");
+class BatchWriteBuilder extends base_1.QueryBuilderBase {
+    queryOptions;
+    commands = [];
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.prepare();
+    }
+    getCommand() {
+        return this.commands;
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    async exec() {
+        return Promise.all(this.commands.map((command) => this.execAndRetry(command)));
+    }
+    async execAndRetry(inputCommand, attempt = 0) {
+        const command = new client_dynamodb_1.BatchWriteItemCommand(inputCommand);
+        const response = await this.queryOptions.client.send(command);
+        const unprocessedItems = response.UnprocessedItems || {};
+        if (Object.keys(unprocessedItems).length > 0) {
+            if (attempt === (this.queryOptions.maxAttempt ?? 5)) {
+                throw new Error('Failed to process all items after maximum retries');
+            }
+            await this.execAndRetry({
+                RequestItems: unprocessedItems,
+            }, attempt + 1);
+        }
+    }
+    chunkItems(items, size) {
+        const result = [];
+        const total = items.length;
+        for (let i = 0; i < total; i += size) {
+            result.push(items.slice(i, i + size));
+        }
+        return result;
+    }
+    prepare() {
+        const chunkedItems = this.chunkItems(this.queryOptions.items, 25);
+        for (const items of chunkedItems) {
+            this.commands.push(this.queryOptions.generateBatchCommand(items));
+        }
+    }
+}
+exports.BatchWriteBuilder = BatchWriteBuilder;