dinah 0.1.2 → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1045 @@
+import { ConditionalCheckFailedException, CreateTableCommand, DeleteTableCommand, DynamoDB, DynamoDBClient, ListTablesCommand, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb";
+import * as Lib from "@aws-sdk/lib-dynamodb";
+import sift from "sift";
+import * as T from "typebox";
+//#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 Repository = class {
+	table;
+	db;
+	constructor(table, db) {
+		this.table = table;
+		this.db = db;
+	}
+	get tableName() {
+		return `${this.db.config?.tableNamePrefix ?? ""}${this.table.def.name}`;
+	}
+	get def() {
+		return this.table.def;
+	}
+	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) {
+		return this.db.get({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+	}
+	async getOrThrow(key, options) {
+		return this.db.getOrThrow({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+	}
+	async put(item, options) {
+		const itemWithDefaults = this.table.def.beforePut ? {
+			...this.table.def.beforePut(item),
+			...item
+		} : item;
+		return this.db.put({
+			table: this.tableName,
+			item: itemWithDefaults,
+			...options
+		});
+	}
+	async update(key, update, options) {
+		const updateWithDefaults = this.table.def.beforeUpdate ? {
+			...this.table.def.beforeUpdate(update),
+			...update
+		} : update;
+		return this.db.update({
+			table: this.tableName,
+			key: this.extractKey(key),
+			update: updateWithDefaults,
+			...options
+		});
+	}
+	async create(item, options) {
+		const itemWithDefaults = this.table.def.beforePut ? {
+			...this.table.def.beforePut(item),
+			...item
+		} : item;
+		return this.db.create({
+			table: this.tableName,
+			item: itemWithDefaults,
+			partitionKeyName: this.table.def.partitionKey,
+			...options
+		});
+	}
+	async upsert(data) {
+		const { update, item, key, ...options } = data;
+		const updateWithDefaults = this.table.def.beforeUpdate ? {
+			...this.table.def.beforeUpdate(update),
+			...update
+		} : update;
+		const itemWithDefaults = this.table.def.beforePut ? {
+			...this.table.def.beforePut(item),
+			...item
+		} : item;
+		return this.db.upsert({
+			table: this.tableName,
+			key: this.extractKey(key),
+			update: updateWithDefaults,
+			item: itemWithDefaults,
+			...options
+		});
+	}
+	async delete(key, options) {
+		return this.db.delete({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+	}
+	async deleteOrThrow(key, options) {
+		return this.db.deleteOrThrow({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		});
+	}
+	async query(query, options) {
+		return this.db.query({
+			table: this.tableName,
+			query,
+			...options
+		});
+	}
+	async *queryPaged(query, options) {
+		yield* this.db.queryPaged({
+			table: this.tableName,
+			query,
+			...options
+		});
+	}
+	async queryGsi(gsi, query, options) {
+		return this.db.query({
+			table: this.tableName,
+			index: gsi,
+			query,
+			...options
+		});
+	}
+	async *queryGsiPaged(gsi, query, options) {
+		yield* this.db.queryPaged({
+			table: this.tableName,
+			index: gsi,
+			query,
+			...options
+		});
+	}
+	async scan(options) {
+		return this.db.scan({
+			table: this.tableName,
+			...options
+		});
+	}
+	async *scanPaged(options) {
+		yield* this.db.scanPaged({
+			table: this.tableName,
+			...options
+		});
+	}
+	async scanGsi(gsi, options) {
+		return this.db.scan({
+			table: this.tableName,
+			index: gsi,
+			...options
+		});
+	}
+	async *scanGsiPaged(gsi, options) {
+		yield* this.db.scanPaged({
+			table: this.tableName,
+			index: gsi,
+			...options
+		});
+	}
+	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
+		} });
+		return {
+			items: items[this.tableName],
+			unprocessed: unprocessed?.[this.tableName]?.keys
+		};
+	}
+	async batchGetOrThrow(keys, options) {
+		return (await this.db.batchGetOrThrow({ [this.tableName]: {
+			keys: keys.map((key) => this.extractKey(key)),
+			...options
+		} }))[this.tableName];
+	}
+	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.table.def.beforePut ? {
+					...this.table.def.beforePut(request.item),
+					...request.item
+				} : request.item
+			};
+		}) });
+		return {
+			items: items[this.tableName],
+			unprocessed: unprocessed?.[this.tableName]
+		};
+	}
+	async trxGet(keys, options) {
+		return this.db.trxGet(...keys.map((key) => ({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...options
+		})));
+	}
+	async trxGetOrThrow(keys, options) {
+		return this.db.trxGetOrThrow(...keys.map((key) => ({
+			table: this.tableName,
+			key: this.extractKey(key),
+			...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.table.def.beforePut ? {
+			...this.table.def.beforePut(item),
+			...item
+		} : item;
+		return {
+			table: this.tableName,
+			type: "PUT",
+			item: itemWithDefaults,
+			...options
+		};
+	}
+	trxUpdateRequest(key, update, options) {
+		const updateWithDefaults = this.table.def.beforeUpdate ? {
+			...this.table.def.beforeUpdate(update),
+			...update
+		} : 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.table.def.beforePut ? {
+			...this.table.def.beforePut(item),
+			...item
+		} : item;
+		return {
+			table: this.tableName,
+			type: "PUT",
+			item: itemWithDefaults,
+			condition,
+			...otherOptions
+		};
+	}
+};
+//#endregion
+//#region src/util.ts
+const resolveAttrType = (schema, attrName) => {
+	if (T.IsString(schema) || T.IsLiteralString(schema)) return T.IsOptional(schema) ? ["S", void 0] : ["S"];
+	if (T.IsNumber(schema) || T.IsLiteralNumber(schema)) return T.IsOptional(schema) ? ["N", void 0] : ["N"];
+	if (T.IsObject(schema)) {
+		const attrSchema = schema.properties[attrName];
+		if (!attrSchema) return [void 0];
+		return resolveAttrType(attrSchema, attrName);
+	}
+	if (T.IsIntersect(schema)) return schema.allOf.flatMap((s) => resolveAttrType(s, attrName));
+	if (T.IsUnion(schema)) return schema.anyOf.flatMap((s) => resolveAttrType(s, attrName));
+	return [];
+};
+const getAttrType = (schema, attrName, allowedTypes = [
+	"S",
+	"N",
+	void 0
+]) => {
+	const resolvedType = resolveAttrType(schema, attrName);
+	if (resolvedType.includes("S") && resolvedType.includes("N")) throw new Error(`Attribute ${attrName} cannot be both a number and a string.`);
+	if (!allowedTypes.includes(void 0) && resolvedType.includes(void 0)) throw new Error(`Attribute ${attrName} cannot be optional.`);
+	return resolvedType.includes("S") ? "S" : "N";
+};
+const extractAttribute = (schema, attrName, allowedTypes) => {
+	return {
+		AttributeName: attrName,
+		AttributeType: getAttrType(schema, attrName, allowedTypes)
+	};
+};
+const extractTableKey = (schema, attrName, allowedTypes) => {
+	return {
+		name: attrName,
+		type: getAttrType(schema, attrName, allowedTypes)
+	};
+};
+const extractTableDesc = (schema, def) => {
+	const gsis = Object.entries(def.gsis ?? {}).map(([indexName, gsi]) => {
+		return {
+			indexName,
+			partitionKey: extractTableKey(schema, gsi.partitionKey),
+			sortKey: gsi.sortKey ? extractTableKey(schema, gsi.sortKey) : void 0,
+			projectionType: Array.isArray(gsi.projection) ? "INCLUDE" : gsi.projection ?? "ALL",
+			nonKeyAttributes: Array.isArray(gsi.projection) ? gsi.projection : void 0
+		};
+	});
+	return {
+		tableName: def.name,
+		billingMode: def.billingMode ?? "PAY_PER_REQUEST",
+		stream: def.stream,
+		partitionKey: extractTableKey(schema, def.partitionKey, ["N", "S"]),
+		sortKey: def.sortKey ? extractTableKey(schema, def.sortKey, ["N", "S"]) : void 0,
+		gsis: gsis.length ? gsis : void 0
+	};
+};
+const chunk = (arr, chunkSize) => {
+	if (chunkSize <= 0) return [];
+	const chunks = [];
+	for (let i = 0; i < arr.length; i += chunkSize) chunks.push(arr.slice(i, i + chunkSize));
+	return chunks;
+};
+const removeUndefined = (obj) => {
+	const stack = [obj];
+	while (stack.length) {
+		const currentObj = stack.pop();
+		if (currentObj !== void 0) Object.entries(currentObj).forEach(([k, v]) => {
+			if (v && v instanceof Object) stack.push(v);
+			else if (v === void 0) delete currentObj[k];
+		});
+	}
+	return obj;
+};
+//#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 Repository(table, this);
+	}
+	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 input = new Lib.PutCommand({
+			TableName: data.table,
+			Item: removeUndefined(data.item),
+			ReturnValues: data.return === "ALL_OLD" ? "ALL_OLD" : void 0,
+			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
+			ConditionExpression: exp.condition(data.condition),
+			ExpressionAttributeNames: exp.attributeNames,
+			ExpressionAttributeValues: exp.attributeValues
+		});
+		const output = await this.client.send(input);
+		return data.return === "ALL_OLD" ? output.Attributes : data;
+	}
+	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: data.return ?? "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 create(data) {
+		const { condition: otherCondition, partitionKeyName, ...options } = data;
+		const condition = { $and: [{ [partitionKeyName]: { $exists: false } }] };
+		if (otherCondition) condition.$and.push(otherCondition);
+		return this.put({
+			...options,
+			condition,
+			return: "ALL_NEW"
+		});
+	}
+	async upsert(data) {
+		const { key, item, update, ...options } = data;
+		try {
+			return await this.update({
+				...options,
+				key,
+				update,
+				return: "ALL_NEW"
+			});
+		} catch (e) {
+			if (e instanceof ConditionalCheckFailedException && !e.Item) return this.create({
+				item,
+				partitionKeyName: Object.keys(key)[0] ?? "",
+				...options
+			});
+			throw e;
+		}
+	}
+	async delete(data) {
+		const exp = new ExpressionBuilder();
+		const input = new Lib.DeleteCommand({
+			TableName: data.table,
+			Key: data.key,
+			ReturnValues: data.return ?? "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;
+	}
+	async drop(client) {
+		await client.send(new DeleteTableCommand({ TableName: this.def.name }));
+	}
+	async createTable(client) {
+		const desc = extractTableDesc(this.schema, this.def);
+		const attributes = /* @__PURE__ */ new Map();
+		const setAttribute = (tableKey) => {
+			attributes.set(tableKey.name, {
+				AttributeName: tableKey.name,
+				AttributeType: tableKey.type
+			});
+		};
+		const keySchema = [{
+			AttributeName: desc.partitionKey.name,
+			KeyType: "HASH"
+		}];
+		setAttribute(desc.partitionKey);
+		if (desc.sortKey) {
+			keySchema.push({
+				AttributeName: desc.sortKey.name,
+				KeyType: "RANGE"
+			});
+			setAttribute(desc.sortKey);
+		}
+		const gsis = desc.gsis?.map((gsi) => {
+			const gsiKeySchema = [{
+				AttributeName: gsi.partitionKey.name,
+				KeyType: "HASH"
+			}];
+			setAttribute(gsi.partitionKey);
+			if (gsi.sortKey) {
+				gsiKeySchema.push({
+					AttributeName: gsi.sortKey.name,
+					KeyType: "RANGE"
+				});
+				setAttribute(gsi.sortKey);
+			}
+			return {
+				IndexName: gsi.indexName,
+				KeySchema: gsiKeySchema,
+				Projection: {
+					ProjectionType: gsi.projectionType,
+					NonKeyAttributes: gsi.nonKeyAttributes
+				}
+			};
+		});
+		await client.send(new CreateTableCommand({
+			TableName: desc.tableName,
+			KeySchema: keySchema,
+			AttributeDefinitions: [...attributes.values()],
+			BillingMode: desc.billingMode,
+			GlobalSecondaryIndexes: gsis,
+			StreamSpecification: desc.stream ? {
+				StreamEnabled: true,
+				StreamViewType: desc.stream
+			} : void 0
+		}));
+		if (desc.ttlAttribute) await client.send(new UpdateTimeToLiveCommand({
+			TableName: desc.tableName,
+			TimeToLiveSpecification: {
+				Enabled: true,
+				AttributeName: desc.ttlAttribute
+			}
+		}));
+	}
+};
+//#endregion
+export { Db, Repository, Table, chunk, extractAttribute, extractTableDesc, extractTableKey, getAttrType, removeUndefined, resolveAttrType };
+
+//# sourceMappingURL=index.mjs.map