dinah 0.1.3 → 0.3.0

package/dist/index.mjs

@@ -0,0 +1,914 @@
+import { i as resolveAttrType, n as extractTableDesc, r as removeUndefined, t as chunk } from "./util-DDOj_NRD.mjs";
+import { CreateTableCommand, DeleteTableCommand, DynamoDB, DynamoDBClient, ListTablesCommand } from "@aws-sdk/client-dynamodb";
+import * as Lib from "@aws-sdk/lib-dynamodb";
+import sift from "sift";
+//#region src/expression-builder.ts
+const attrTypes = [
+	"S",
+	"SS",
+	"N",
+	"NS",
+	"B",
+	"BS",
+	"BOOL",
+	"NULL",
+	"L",
+	"M"
+];
+const comparatorOps = {
+	$eq: "=",
+	$ne: "<>",
+	$gt: ">",
+	$gte: ">=",
+	$lt: "<",
+	$lte: "<="
+};
+const isOperation = (val) => {
+	if (!val || typeof val !== "object" || Array.isArray(val)) return false;
+	return Object.keys(val).every((op) => op.startsWith("$"));
+};
+var ExpressionBuilder = class {
+	attrNames = /* @__PURE__ */ new Map();
+	attrValues = /* @__PURE__ */ new Map();
+	get attributeNames() {
+		return this.attrNames.size ? Object.fromEntries([...this.attrNames.entries()].map(([name, placeholder]) => [placeholder, name])) : void 0;
+	}
+	get attributeValues() {
+		return this.attrValues.size ? Object.fromEntries([...this.attrValues.entries()].map(([value, placeholder]) => [placeholder, value])) : void 0;
+	}
+	reset() {
+		this.attrNames.clear();
+		this.attrValues.clear();
+	}
+	getPathSub(path) {
+		const segments = path.split(".");
+		const placeholders = [];
+		for (const segment of segments) {
+			let placeholder = this.attrNames.get(segment);
+			if (!placeholder) {
+				placeholder = `#${this.attrNames.size}`;
+				this.attrNames.set(segment, placeholder);
+			}
+			placeholders.push(placeholder);
+		}
+		return placeholders.join(".");
+	}
+	getValueSub(value) {
+		let placeholder = this.attrValues.get(value);
+		if (!placeholder) {
+			placeholder = `:${this.attrValues.size}`;
+			this.attrValues.set(value, placeholder);
+		}
+		return placeholder;
+	}
+	getValueOrPathSub(pathOrValue) {
+		if (isOperation(pathOrValue)) {
+			if (pathOrValue.$path) return this.getPathSub(pathOrValue.$path);
+			throw new Error("Expected $path or operand.");
+		}
+		return this.getValueSub(pathOrValue);
+	}
+	projection(paths) {
+		return paths?.map((path) => this.getPathSub(path)).join(", ");
+	}
+	condition(expression) {
+		if (!expression) return void 0;
+		const expressions = [];
+		for (const [key, val] of Object.entries(expression)) if (key === "$and") {
+			if (!Array.isArray(val)) throw new Error("$and expects an array operand.");
+			expressions.push(`(${val.map((v) => this.condition(v)).join(" AND ")})`);
+		} else if (key === "$or" && Array.isArray(val)) {
+			if (!Array.isArray(val)) throw new Error("$or expects an array operand.");
+			expressions.push(`(${val.map((v) => this.condition(v)).join(" OR ")})`);
+		} else if (key === "$not") {
+			if (!val || typeof val !== "object") throw new Error("$not expects an object operand.");
+			expressions.push(`NOT ${this.condition(val)}`);
+		} else if (!key.startsWith("$")) expressions.push(this.resolveCondition(key, val));
+		else throw new Error(`Unexpected operator "${key}". Expected attribute path or compound operator.`);
+		return expressions.join(" AND ");
+	}
+	update(expression) {
+		if (expression === void 0) return void 0;
+		const setOperations = [];
+		const removeOperations = [];
+		const setAddOperations = [];
+		const setDelOperations = [];
+		for (const [path, valOrOperation] of Object.entries(expression)) {
+			const placeholder = this.getPathSub(path);
+			if (valOrOperation === void 0) removeOperations.push(placeholder);
+			else if (isOperation(valOrOperation)) if (valOrOperation.$remove === true) removeOperations.push(placeholder);
+			else if (valOrOperation.$setAdd !== void 0 || valOrOperation.$setDel !== void 0) {
+				const operations = valOrOperation.$setAdd ? setAddOperations : setDelOperations;
+				const operand = valOrOperation.$setAdd ?? valOrOperation.$setDel;
+				operations.push(`${placeholder} ${this.getValueSub(operand instanceof Set ? operand : new Set([operand].flat()))}`);
+			} else setOperations.push(`${placeholder} = ${this.resolveSetOperand(path, valOrOperation)}`);
+			else setOperations.push(`${placeholder} = ${this.getValueSub(valOrOperation)}`);
+		}
+		let updateExpression = "";
+		if (setOperations.length) updateExpression += `SET ${setOperations.join(", ")} `;
+		if (removeOperations.length) updateExpression += `REMOVE ${removeOperations.join(", ")} `;
+		if (setAddOperations.length) updateExpression += `ADD ${setAddOperations.join(", ")} `;
+		if (setDelOperations.length) updateExpression += `DELETE ${setDelOperations.join(", ")} `;
+		return updateExpression;
+	}
+	resolveCondition(path, exp) {
+		if (!exp || typeof exp !== "object" || !Object.keys(exp).at(0)?.startsWith("$")) return this.resolveCondition(path, { $eq: exp });
+		const placeholder = this.getPathSub(path);
+		const [operator, operand] = Object.entries(exp).at(0) ?? [""];
+		if (comparatorOps[operator]) {
+			if (isOperation(operand) && operand.$path) return `${placeholder} ${comparatorOps[operator]} ${this.getPathSub(operand.$path)}`;
+			if (![
+				"string",
+				"boolean",
+				"number"
+			].includes(typeof operand)) throw new Error(`${operator} expects a primitive/scalar operand.`);
+			return `${placeholder} ${comparatorOps[operator]} ${this.getValueSub(operand)}`;
+		}
+		switch (operator) {
+			case "$in":
+				if (!Array.isArray(operand)) throw new Error("$in operator expects an array operand.");
+				return `${placeholder} IN (${operand.map((op) => this.getValueSub(op)).join(", ")})`;
+			case "$nin":
+				if (!Array.isArray(operand)) throw new Error("$nin operator expects an array operand.");
+				return `${placeholder} NOT IN (${operand.map((op) => this.getValueSub(op)).join(", ")})`;
+			case "$prefix":
+				if (typeof operand !== "string") throw new Error("$prefix operator expects a string operand.");
+				return `begins_with(${placeholder}, ${this.getValueSub(operand)})`;
+			case "$includes": return `contains(${placeholder}, ${this.getValueSub(operand)})`;
+			case "$between":
+				if (!Array.isArray(operand) || operand.length !== 2) throw new Error("$between operator expects an array operand of exactly two values.");
+				return `${placeholder} BETWEEN ${this.getValueSub(operand[0])} AND ${this.getValueSub(operand[1])}`;
+			case "$exists":
+				if (typeof operand !== "boolean") throw new Error("$exists operator expects a boolean operand.");
+				return operand ? `attribute_exists(${placeholder})` : `attribute_not_exists(${placeholder})`;
+			case "$type":
+				if (!attrTypes.includes(operand)) throw new Error(`$type operator expects operand to be one of ${attrTypes.join(",")}`);
+				return `attribute_type(${placeholder})`;
+			case "$size": {
+				const sizeExp = typeof operand === "number" ? { $eq: operand } : operand;
+				if (!sizeExp || typeof sizeExp !== "object" || !Object.keys(sizeExp).at(0)?.startsWith("$")) throw new Error("$size operator expects a number operand or a comparator object.");
+				const [sizeOperator, sizeOperand] = Object.entries(sizeExp).at(0) ?? [""];
+				if (!comparatorOps[sizeOperator]) throw new Error("$size operator expects a number operand or a comparator object.");
+				if (![
+					"string",
+					"boolean",
+					"number"
+				].includes(typeof sizeOperand)) throw new Error(`${operator} expects a primitive/scalar operand.`);
+				return `size(${placeholder}) ${comparatorOps[sizeOperator]} ${this.getValueSub(sizeOperand)}`;
+			}
+			default: throw new Error(`Invalid operator "${operator}"`);
+		}
+	}
+	resolveSetOperand(path, operand) {
+		if (isOperation(operand)) {
+			if (operand.$ifNotExists) {
+				const params = Array.isArray(operand.$ifNotExists) ? operand.$ifNotExists : [path, operand.$ifNotExists];
+				return `if_not_exists(${this.getPathSub(params[0])}, ${this.resolveSetOperand(path, params[1])})`;
+			}
+			if (operand.$set) return this.resolveSetOperand(path, operand.$set);
+			if (operand.$plus !== void 0 || operand.$minus !== void 0) {
+				const mathOperator = operand.$plus ? "+" : "-";
+				const mathOperand = operand.$plus ?? operand.$minus;
+				return `${(Array.isArray(mathOperand) ? mathOperand : [{ $path: path }, mathOperand]).map((param) => this.resolveSetOperand(path, param)).join(` ${mathOperator} `)}`;
+			}
+			if (operand.$append !== void 0 || operand.$prepend !== void 0) {
+				const listOperand = operand.$append ?? operand.$prepend;
+				const resolvedListOperand = isOperation(listOperand) ? listOperand : [listOperand].flat();
+				return `list_append(${(operand.$append ? [{ $path: path }, resolvedListOperand] : [resolvedListOperand, { $path: path }]).map((param) => this.resolveSetOperand(path, param)).join(", ")})`;
+			}
+		}
+		return this.getValueOrPathSub(operand);
+	}
+};
+//#endregion
+//#region src/repo.ts
+var AbstractRepo = class {
+	db;
+	constructor(db) {
+		this.db = db;
+	}
+	get tableName() {
+		return `${this.db.config?.tableNamePrefix ?? ""}${this.table.def.name}`;
+	}
+	get defaultPutData() {
+		return {};
+	}
+	get defaultUpdateData() {
+		return {};
+	}
+	transformItem(item) {
+		return item;
+	}
+	extractKey(item) {
+		const { partitionKey, sortKey } = this.table.def;
+		if (sortKey) return {
+			[partitionKey]: item[partitionKey],
+			[sortKey]: item[sortKey]
+		};
+		return { [partitionKey]: item[partitionKey] };
+	}
+	async get(key, options) {
+		const item = await this.db.get({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+		return item && this.applyTransformIfNeeded(item, options);
+	}
+	async getOrThrow(key, options) {
+		const item = await this.db.getOrThrow({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+		return this.applyTransformIfNeeded(item, options);
+	}
+	async put(item, options) {
+		const itemWithDefaults = {
+			...this.defaultPutData,
+			...item
+		};
+		const result = await this.db.put({
+			table: this.tableName,
+			item: itemWithDefaults,
+			...options
+		});
+		return this.applyTransformIfNeeded(result);
+	}
+	async update(key, update, options) {
+		const updateWithDefaults = {
+			...this.defaultUpdateData,
+			...update
+		};
+		const result = await this.db.update({
+			table: this.tableName,
+			key: this.extractKey(key),
+			update: updateWithDefaults,
+			...options
+		});
+		return this.applyTransformIfNeeded(result);
+	}
+	async create(item, options) {
+		const { condition: otherCondition, ...otherOptions } = options ?? {};
+		const condition = { $and: [{ [this.table.def.partitionKey]: { $exists: false } }] };
+		if (otherCondition) condition.$and.push(otherCondition);
+		return this.put(item, {
+			condition,
+			...otherOptions
+		});
+	}
+	async delete(key, options) {
+		const item = await this.db.delete({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+		return item && this.applyTransformIfNeeded(item);
+	}
+	async deleteOrThrow(key, options) {
+		const item = await this.db.deleteOrThrow({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+		return this.applyTransformIfNeeded(item);
+	}
+	async query(query, options) {
+		const items = await this.db.query({
+			table: this.tableName,
+			query,
+			...options
+		});
+		return this.applyTransformsIfNeeded(items, options);
+	}
+	async *queryPaged(query, options) {
+		for await (const page of this.db.queryPaged({
+			table: this.tableName,
+			query,
+			...options
+		})) yield this.applyTransformsIfNeeded(page, options);
+	}
+	async queryGsi(gsi, query, options) {
+		const items = await this.db.query({
+			table: this.tableName,
+			index: gsi,
+			query,
+			...options
+		});
+		return this.applyTransformsIfNeeded(items, {
+			...options,
+			gsi
+		});
+	}
+	async *queryGsiPaged(gsi, query, options) {
+		for await (const page of this.db.queryPaged({
+			table: this.tableName,
+			index: gsi,
+			query,
+			...options
+		})) yield this.applyTransformsIfNeeded(page, {
+			...options,
+			gsi
+		});
+	}
+	async scan(options) {
+		const items = await this.db.scan({
+			table: this.tableName,
+			...options
+		});
+		return this.applyTransformsIfNeeded(items, options);
+	}
+	async *scanPaged(options) {
+		for await (const page of this.db.scanPaged({
+			table: this.tableName,
+			...options
+		})) yield this.applyTransformsIfNeeded(page, options);
+	}
+	async scanGsi(gsi, options) {
+		const items = await this.db.scan({
+			table: this.tableName,
+			index: gsi,
+			...options
+		});
+		return this.applyTransformsIfNeeded(items, {
+			...options,
+			gsi
+		});
+	}
+	async *scanGsiPaged(gsi, options) {
+		for await (const page of this.db.scanPaged({
+			table: this.tableName,
+			index: gsi,
+			...options
+		})) yield this.applyTransformsIfNeeded(page, {
+			...options,
+			gsi
+		});
+	}
+	async exists(options) {
+		return this.db.exists({
+			table: this.tableName,
+			projection: [this.table.def.partitionKey],
+			...options
+		});
+	}
+	async existsGsi(gsi, options) {
+		return this.db.exists({
+			table: this.tableName,
+			index: gsi,
+			projection: [this.table.def.partitionKey],
+			...options
+		});
+	}
+	async batchGet(keys, options) {
+		const { items, unprocessed } = await this.db.batchGet({ [this.tableName]: {
+			keys: keys.map((key) => this.extractKey(key)),
+			...options
+		} });
+		const tableItems = items[this.tableName];
+		return {
+			items: tableItems && this.applyTransformsIfNeeded(tableItems, options),
+			unprocessed: unprocessed?.[this.tableName]?.keys
+		};
+	}
+	async batchGetOrThrow(keys, options) {
+		const result = await this.db.batchGetOrThrow({ [this.tableName]: {
+			keys: keys.map((key) => this.extractKey(key)),
+			...options
+		} });
+		return this.applyTransformsIfNeeded(result[this.tableName] ?? [], options);
+	}
+	async batchWrite(requests) {
+		const { items, unprocessed } = await this.db.batchWrite({ [this.tableName]: requests.map((request) => {
+			if (request.type === "DELETE") return {
+				type: "DELETE",
+				key: this.extractKey(request.key)
+			};
+			else return {
+				type: "PUT",
+				item: {
+					...this.defaultPutData,
+					...request.item
+				}
+			};
+		}) });
+		return {
+			items: items[this.tableName],
+			unprocessed: unprocessed?.[this.tableName]
+		};
+	}
+	async trxGet(keys, options) {
+		return (await this.db.trxGet(...keys.map((key) => ({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		})))).map((item) => item && this.applyTransformIfNeeded(item, options));
+	}
+	async trxGetOrThrow(keys, options) {
+		const items = await this.db.trxGetOrThrow(...keys.map((key) => ({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		})));
+		return this.applyTransformsIfNeeded(items, options);
+	}
+	async trxWrite(...requests) {
+		await this.db.trxWrite(...requests.map((request) => {
+			switch (request.type) {
+				case "CONDITION": {
+					const { key, condition, ...options } = request;
+					return this.trxConditionRequest(key, condition, options);
+				}
+				case "DELETE": {
+					const { key, ...options } = request;
+					return this.trxDeleteRequest(key, options);
+				}
+				case "PUT": {
+					const { item, ...options } = request;
+					return this.trxPutRequest(item, options);
+				}
+				case "UPDATE": {
+					const { key, update, ...options } = request;
+					return this.trxUpdateRequest(key, update, options);
+				}
+				default: throw new Error("Unexpected request type.");
+			}
+		}));
+	}
+	async trxDelete(keys, options) {
+		return this.db.trxWrite(...keys.map((key) => this.trxDeleteRequest(key, options)));
+	}
+	async trxPut(items, options) {
+		return this.db.trxWrite(...items.map((item) => this.trxPutRequest(item, options)));
+	}
+	async trxUpdate(keys, update, options) {
+		return this.db.trxWrite(...keys.map((key) => this.trxUpdateRequest(key, update, options)));
+	}
+	async trxCreate(items, options) {
+		return this.db.trxWrite(...items.map((item) => this.trxCreateRequest(item, options)));
+	}
+	trxGetRequest(key, options) {
+		return {
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		};
+	}
+	trxDeleteRequest(key, options) {
+		return {
+			table: this.tableName,
+			type: "DELETE",
+			key: this.extractKey(key),
+			...options
+		};
+	}
+	trxConditionRequest(key, condition, options) {
+		return {
+			table: this.tableName,
+			type: "CONDITION",
+			key: this.extractKey(key),
+			condition,
+			...options
+		};
+	}
+	trxPutRequest(item, options) {
+		const itemWithDefaults = {
+			...this.defaultPutData,
+			...item
+		};
+		return {
+			table: this.tableName,
+			type: "PUT",
+			item: itemWithDefaults,
+			...options
+		};
+	}
+	trxUpdateRequest(key, update, options) {
+		const updateWithDefaults = {
+			...this.defaultUpdateData,
+			...update
+		};
+		return {
+			table: this.tableName,
+			type: "UPDATE",
+			key: this.extractKey(key),
+			update: updateWithDefaults,
+			...options
+		};
+	}
+	trxCreateRequest(item, options) {
+		const { condition: otherCondition, ...otherOptions } = options ?? {};
+		const condition = { $and: [{ [this.table.def.partitionKey]: { $exists: false } }] };
+		if (otherCondition) condition.$and.push(otherCondition);
+		const itemWithDefaults = {
+			...this.defaultPutData,
+			...item
+		};
+		return {
+			table: this.tableName,
+			type: "PUT",
+			item: itemWithDefaults,
+			condition,
+			...otherOptions
+		};
+	}
+	applyTransformsIfNeeded(items, options) {
+		if (options?.projection?.length) return items;
+		if (options?.gsi) {
+			const gsiProj = this.table.def.gsis?.[options.gsi]?.projection;
+			if (gsiProj === "KEYS_ONLY" || Array.isArray(gsiProj)) return items;
+		}
+		return items.map((item) => this.transformItem(item));
+	}
+	applyTransformIfNeeded(item, options) {
+		const [transformedItem] = this.applyTransformsIfNeeded([item], options);
+		return transformedItem;
+	}
+};
+var Repo = class extends AbstractRepo {
+	table;
+	constructor(db, table) {
+		super(db);
+		this.table = table;
+	}
+};
+//#endregion
+//#region src/db.ts
+var Db = class {
+	client;
+	config;
+	constructor(clientOrConfig, dbConfig) {
+		if (clientOrConfig instanceof DynamoDBClient || clientOrConfig instanceof DynamoDB) this.client = Lib.DynamoDBDocumentClient.from(new DynamoDBClient(clientOrConfig));
+		else {
+			const { endpoint, ...clientConfig } = clientOrConfig;
+			this.client = Lib.DynamoDBDocumentClient.from(new DynamoDBClient({
+				endpoint: endpoint || void 0,
+				...clientConfig
+			}));
+		}
+		this.config = dbConfig;
+	}
+	createRepo(table) {
+		return new Repo(this, table);
+	}
+	async createTable(table) {
+		await this.client.send(new CreateTableCommand(extractTableDesc(table)));
+	}
+	async deleteTable(tableName) {
+		await this.client.send(new DeleteTableCommand({ TableName: tableName }));
+	}
+	async listTables(data) {
+		const tables = [];
+		let lastEvaluatedTableName;
+		do {
+			const output = await this.client.send(new ListTablesCommand({
+				Limit: data?.limit,
+				ExclusiveStartTableName: lastEvaluatedTableName
+			}));
+			tables.push(...output.TableNames ?? []);
+			lastEvaluatedTableName = output.LastEvaluatedTableName;
+		} while (lastEvaluatedTableName);
+		return tables;
+	}
+	async get(data) {
+		const exp = new ExpressionBuilder();
+		const input = new Lib.GetCommand({
+			TableName: data.table,
+			Key: data.key,
+			ConsistentRead: data.consistent,
+			ProjectionExpression: exp.projection(data.projection),
+			ExpressionAttributeNames: exp.attributeNames
+		});
+		const output = await this.client.send(input);
+		if (output.Item && data.condition) {
+			if (!sift(data.condition)(output.Item)) return;
+		}
+		return output.Item;
+	}
+	async getOrThrow(data) {
+		const item = await this.get(data);
+		if (!item) throw new Error(`Item not found in "${data.table}" table.`);
+		return item;
+	}
+	async put(data) {
+		const exp = new ExpressionBuilder();
+		const item = removeUndefined(data.item);
+		const input = new Lib.PutCommand({
+			TableName: data.table,
+			Item: item,
+			ReturnValues: data.returnOld ? "ALL_OLD" : "NONE",
+			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
+			ConditionExpression: exp.condition(data.condition),
+			ExpressionAttributeNames: exp.attributeNames,
+			ExpressionAttributeValues: exp.attributeValues
+		});
+		const output = await this.client.send(input);
+		return data.returnOld ? output.Attributes : item;
+	}
+	async update(data) {
+		const exp = new ExpressionBuilder();
+		const condition = { $and: Object.keys(data.key).map((field) => ({ [field]: { $exists: true } })) };
+		if (data.condition) condition.$and.push(data.condition);
+		const input = new Lib.UpdateCommand({
+			TableName: data.table,
+			Key: data.key,
+			ReturnValues: "ALL_NEW",
+			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
+			UpdateExpression: exp.update(data.update),
+			ConditionExpression: exp.condition(condition),
+			ExpressionAttributeNames: exp.attributeNames,
+			ExpressionAttributeValues: exp.attributeValues
+		});
+		return (await this.client.send(input)).Attributes;
+	}
+	async delete(data) {
+		const exp = new ExpressionBuilder();
+		const input = new Lib.DeleteCommand({
+			TableName: data.table,
+			Key: data.key,
+			ReturnValues: "ALL_OLD",
+			ConditionExpression: exp.condition(data.condition),
+			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
+			ExpressionAttributeNames: exp.attributeNames,
+			ExpressionAttributeValues: exp.attributeValues
+		});
+		return (await this.client.send(input)).Attributes;
+	}
+	async deleteOrThrow(data) {
+		const item = await this.delete(data);
+		if (!item) throw new Error(`Item not found in "${data.table}" table.`);
+		return item;
+	}
+	async *queryPaged(data) {
+		const exp = new ExpressionBuilder();
+		let lastEvaluatedKey = data.startKey;
+		do {
+			const input = new Lib.QueryCommand({
+				TableName: data.table,
+				IndexName: data.index,
+				ExclusiveStartKey: lastEvaluatedKey,
+				Limit: data.limit,
+				ScanIndexForward: data.sort !== "DESC",
+				ConsistentRead: data.consistent,
+				KeyConditionExpression: exp.condition(data.query),
+				ProjectionExpression: exp.projection(data.projection),
+				FilterExpression: exp.condition(data.filter),
+				ExpressionAttributeNames: exp.attributeNames,
+				ExpressionAttributeValues: exp.attributeValues
+			});
+			const output = await this.client.send(input);
+			if (output.Items?.length) yield output.Items;
+			lastEvaluatedKey = output.LastEvaluatedKey;
+		} while (lastEvaluatedKey);
+	}
+	async query(data) {
+		const items = [];
+		for await (const page of this.queryPaged(data)) items.push(...page);
+		return items;
+	}
+	async *scanPaged(data) {
+		const exp = new ExpressionBuilder();
+		const totalSegments = data.parallel ?? 1;
+		const segments = [...Array(totalSegments).keys()];
+		const lastEvaluatedKeys = segments.map(() => data.startKey);
+		do {
+			const items = (await Promise.all(segments.map(async (segment) => {
+				if (lastEvaluatedKeys[segment] === null) return [];
+				const input = new Lib.ScanCommand({
+					ExclusiveStartKey: lastEvaluatedKeys[segment],
+					Segment: segment,
+					TotalSegments: totalSegments,
+					TableName: data.table,
+					IndexName: data.index,
+					Limit: data.limit,
+					ConsistentRead: data.consistent,
+					ProjectionExpression: exp.projection(data.projection),
+					FilterExpression: exp.condition(data.filter),
+					ExpressionAttributeNames: exp.attributeNames,
+					ExpressionAttributeValues: exp.attributeValues
+				});
+				const output = await this.client.send(input);
+				lastEvaluatedKeys[segment] = output.LastEvaluatedKey ?? null;
+				return output.Items ?? [];
+			}))).flat();
+			if (items.length) yield items;
+		} while (lastEvaluatedKeys.some((key) => key !== null));
+	}
+	async scan(data) {
+		const items = [];
+		for await (const page of this.scanPaged(data)) items.push(...page);
+		return items;
+	}
+	async exists(data) {
+		const { query, ...otherOptions } = data;
+		const sharedOptions = {
+			...otherOptions,
+			limit: data.filter ? void 0 : 1
+		};
+		const pagedItems = query ? this.queryPaged({
+			query,
+			...sharedOptions
+		}) : this.scanPaged(sharedOptions);
+		for await (const items of pagedItems) if (items.length) return true;
+		return false;
+	}
+	async batchGet(data) {
+		const result = { items: {} };
+		const tableData = Object.fromEntries(Object.entries(data).map(([table, request]) => {
+			const exp = new ExpressionBuilder();
+			const sifter = request?.condition ? sift(request?.condition) : void 0;
+			result.items[table] = [];
+			return [table, {
+				request: {
+					ConsistentRead: request?.consistent,
+					ProjectionExpression: exp.projection(request?.projection),
+					ExpressionAttributeNames: exp.attributeNames
+				},
+				keyNames: Object.keys(request.keys.at(0) ?? {}),
+				itemIndexMap: /* @__PURE__ */ new Map(),
+				sifter
+			}];
+		}));
+		const flattenedBatches = Object.entries(data).flatMap(([table, request]) => {
+			return request.keys.map((key, i) => {
+				const itemIndexKey = tableData[table]?.keyNames.map((keyName) => key[keyName]).join("|") ?? "";
+				tableData[table]?.itemIndexMap.set(itemIndexKey, i);
+				return [table, key];
+			});
+		});
+		let batchSize = 100;
+		let retryCount = 0;
+		while (flattenedBatches.length && retryCount < 5) {
+			const batch = flattenedBatches.splice(0, batchSize || 1);
+			const request = {};
+			for (const [table, key] of batch) {
+				if (!request[table]) request[table] = {
+					...tableData[table]?.request,
+					Keys: []
+				};
+				request[table].Keys?.push(key);
+			}
+			const input = new Lib.BatchGetCommand({ RequestItems: request });
+			const output = await this.client.send(input);
+			for (const [table, items] of Object.entries(output.Responses ?? {})) {
+				if (!result.items[table]) continue;
+				for (const item of items) {
+					if (tableData[table]?.sifter && !tableData[table].sifter(item)) continue;
+					result.items[table].push(item);
+				}
+			}
+			let unprocessedKeyCount = 0;
+			for (const [table, request] of Object.entries(output.UnprocessedKeys ?? {})) {
+				const unprocessed = (request.Keys ?? []).map((key) => [table, key]);
+				flattenedBatches.push(...unprocessed);
+				unprocessedKeyCount += unprocessed.length;
+			}
+			if (!unprocessedKeyCount) {
+				retryCount = 0;
+				continue;
+			}
+			batchSize -= Math.floor(unprocessedKeyCount / 2);
+			retryCount++;
+		}
+		if (flattenedBatches.length) {
+			result.unprocessed = {};
+			for (const [table, key] of flattenedBatches) {
+				if (!result.unprocessed[table]) result.unprocessed[table] = {
+					...tableData[table]?.request,
+					keys: []
+				};
+				result.unprocessed[table].keys.push(key);
+			}
+		}
+		for (const [table, items] of Object.entries(result.items)) {
+			const itemIndexMap = tableData[table]?.itemIndexMap;
+			const keyNames = tableData[table]?.keyNames;
+			if (!itemIndexMap || !keyNames) continue;
+			items.sort((item1, item2) => {
+				const item1IndexKey = keyNames.map((keyName) => item1[keyName]).join("|");
+				const item2IndexKey = keyNames.map((keyName) => item2[keyName]).join("|");
+				return (itemIndexMap.get(item1IndexKey) ?? 0) - (itemIndexMap.get(item2IndexKey) ?? 0);
+			});
+		}
+		return result;
+	}
+	async batchGetOrThrow(data) {
+		const { items, unprocessed } = await this.batchGet(data);
+		for (const table of Object.keys(data)) {
+			if (unprocessed?.[table]) throw new Error(`One or more batch get requests were not processed in "${table}" table.`);
+			if (items[table]?.length !== data[table]?.keys?.length) throw new Error(`One or more items were not found in "${table}" table.`);
+		}
+		return items;
+	}
+	async batchWrite(data) {
+		const result = { items: {} };
+		const flattenedBatches = Object.keys(data).flatMap((table) => {
+			return data[table]?.map((r) => {
+				if (r.type === "DELETE") return [table, { DeleteRequest: { Key: r.key } }];
+				else return [table, { PutRequest: { Item: r.item } }];
+			}) ?? [];
+		});
+		let batchSize = 25;
+		let retryCount = 0;
+		while (flattenedBatches.length && retryCount < 5) {
+			const batch = flattenedBatches.splice(0, batchSize || 1);
+			const request = {};
+			for (const [table, req] of batch) {
+				if (!request[table]) request[table] = [];
+				request[table].push(req);
+			}
+			const input = new Lib.BatchWriteCommand({ RequestItems: request });
+			const output = await this.client.send(input);
+			let unprocessedKeyCount = 0;
+			for (const [table, requests] of Object.entries(output.UnprocessedItems ?? {})) for (const request of requests) {
+				flattenedBatches.push([table, request]);
+				unprocessedKeyCount++;
+			}
+			if (!unprocessedKeyCount) {
+				retryCount = 0;
+				continue;
+			}
+			batchSize -= Math.floor(unprocessedKeyCount / 2);
+			retryCount++;
+		}
+		if (flattenedBatches.length) {
+			result.unprocessed = {};
+			for (const [table, request] of flattenedBatches) {
+				if (!result.unprocessed[table]) result.unprocessed[table] = [];
+				if ("DeleteRequest" in request && request.DeleteRequest?.Key) result.unprocessed[table].push({
+					type: "DELETE",
+					key: request.DeleteRequest.Key
+				});
+				else if ("PutRequest" in request && request.PutRequest?.Item) result.unprocessed[table].push({
+					type: "PUT",
+					item: request.PutRequest.Item
+				});
+			}
+		}
+		return result;
+	}
+	async trxGet(...requests) {
+		const trxItems = requests.map((request) => {
+			const exp = new ExpressionBuilder();
+			return { Get: {
+				Key: request.key,
+				TableName: request.table,
+				ProjectionExpression: exp.projection(request?.projection),
+				ExpressionAttributeNames: exp.attributeNames
+			} };
+		});
+		const input = new Lib.TransactGetCommand({ TransactItems: trxItems });
+		return (await this.client.send(input)).Responses?.map((response, i) => {
+			if (requests[i]?.condition && !sift(requests[i].condition)(response.Item)) return;
+			return response.Item;
+		}) ?? [];
+	}
+	async trxGetOrThrow(...requests) {
+		const items = await this.trxGet(...requests);
+		for (let i = 0; i < items.length; i++) if (!items[i]) throw new Error(`One or more items were not found in "${requests[i]?.table}" table.`);
+		return items;
+	}
+	async trxWrite(...requests) {
+		const trxItems = requests.map((request) => {
+			const exp = new ExpressionBuilder();
+			if (request.type === "CONDITION" || request.type === "DELETE") return { [request.type === "CONDITION" ? "ConditionCheck" : "Delete"]: {
+				TableName: request.table,
+				Key: request.key,
+				ConditionExpression: exp.condition(request.condition),
+				ExpressionAttributeNames: exp.attributeNames,
+				ExpressionAttributeValues: exp.attributeValues
+			} };
+			if (request.type === "PUT") return { Put: {
+				TableName: request.table,
+				Item: removeUndefined(request.item),
+				ConditionExpression: exp.condition(request.condition),
+				ExpressionAttributeNames: exp.attributeNames,
+				ExpressionAttributeValues: exp.attributeValues
+			} };
+			return { Update: {
+				Key: request.key,
+				TableName: request.table,
+				UpdateExpression: exp.update(request.update),
+				ConditionExpression: exp.condition(request.condition),
+				ExpressionAttributeNames: exp.attributeNames,
+				ExpressionAttributeValues: exp.attributeValues
+			} };
+		});
+		const input = new Lib.TransactWriteCommand({ TransactItems: trxItems });
+		await this.client.send(input);
+	}
+};
+//#endregion
+//#region src/table.ts
+var Table = class {
+	schema;
+	def;
+	constructor(schema, def) {
+		this.schema = schema;
+		this.def = def;
+	}
+};
+//#endregion
+export { AbstractRepo, Db, Repo, Table, chunk, extractTableDesc, removeUndefined, resolveAttrType };
+
+//# sourceMappingURL=index.mjs.map