dinah 0.11.1 → 0.13.0

package/README.md

@@ -99,13 +99,18 @@ const UserTable = new Table(
 
 ### Using the Repository Class
 
-`Repo` is the recommended way to interact with DynamoDB. For a plain repo with no configuration, use `db.createRepo`:
+`Repo` is the recommended way to interact with DynamoDB. Use `db.makeRepo` to create a repo inline, with or without configuration:
 
 ```typescript
 const userRepo = db.makeRepo(UserTable);
+
+const userRepo = db.makeRepo(UserTable, {
+  defaultPutData: () => ({ createdAt: Date.now() }),
+  defaultUpdateData: () => ({ updatedAt: Date.now() }),
+});
 ```
 
-For repos with defaults, transforms, or attribute rules, use `makeRepo` to define a class (see [Repository Configuration](#repository-configuration)):
+To create a named, reusable repo class, use the standalone `makeRepo` (see [Repository Configuration](#repository-configuration)):
 
 ```typescript
 import { makeRepo } from "dinah";

package/dist/cdk.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_util = require("./util-D88GS6Gt.cjs");
+const require_util = require("./util-DT6vwquI.cjs");
 let aws_cdk_lib_aws_dynamodb = require("aws-cdk-lib/aws-dynamodb");
 aws_cdk_lib_aws_dynamodb = require_util.__toESM(aws_cdk_lib_aws_dynamodb, 1);
 //#region src/cdk.ts

package/dist/cdk.d.cts

@@ -1,4 +1,4 @@
-import { t as Table } from "./table-BQvKnaNX.cjs";
+import { t as Table } from "./table-D814Vwjm.cjs";
 import { TSchema } from "typebox";
 import * as cdk from "aws-cdk-lib/aws-dynamodb";
 

package/dist/cdk.d.mts

@@ -1,4 +1,4 @@
-import { t as Table } from "./table-D_frY5EF.mjs";
+import { t as Table } from "./table-CatYaz7J.mjs";
 import { TSchema } from "typebox";
 import * as cdk from "aws-cdk-lib/aws-dynamodb";
 

package/dist/cdk.mjs

@@ -1,4 +1,4 @@
-import { i as resolveAttrType } from "./util-BfKXObBN.mjs";
+import { a as resolveAttrType } from "./util-0kc6E2VD.mjs";
 import * as cdk from "aws-cdk-lib/aws-dynamodb";
 //#region src/cdk.ts
 const resolveAttrs = (schema, attrNames) => {

package/dist/index.cjs

@@ -1,8 +1,28 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_util = require("./util-D88GS6Gt.cjs");
+const require_util = require("./util-DT6vwquI.cjs");
 let _aws_sdk_client_dynamodb = require("@aws-sdk/client-dynamodb");
 let _aws_sdk_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
 _aws_sdk_lib_dynamodb = require_util.__toESM(_aws_sdk_lib_dynamodb, 1);
+//#region src/error.ts
+function dinahErrorMessage(details) {
+	switch (details.type) {
+		case "NOT_FOUND": return `${details.resource ?? "Item"} not found: ${JSON.stringify(details.key)}`;
+		case "CONDITIONAL_CHECK_FAILED": return details.key ? `${details.resource ?? "Item"} condition check failed: ${JSON.stringify(details.key)}` : `${details.resource ?? "Item"} condition check failed`;
+		case "VALIDATION": return `Validation error: ${details.message}`;
+		case "DATA_INTEGRITY": return `Data integrity error: ${details.message}`;
+		case "TRANSACTION_CANCELED": return `Transaction canceled: ${details.reasons.map((r) => r.type).join(", ")}`;
+	}
+}
+var DinahError = class extends Error {
+	details;
+	constructor(details, options) {
+		super(dinahErrorMessage(details), options);
+		this.name = "DinahError";
+		this.details = details;
+	}
+};
+const isDinahError = (err) => err instanceof DinahError;
+//#endregion
 //#region src/expression-builder.ts
 const attrTypes = [
 	"S",
@@ -225,8 +245,15 @@ var Repo = class {
 	get tableName() {
 		return `${this.db.config?.tableNamePrefix ?? ""}${this.table.def.name}`;
 	}
-	get defaultPutData() {
-		return this.config.defaultPutData?.() ?? {};
+	get resourceName() {
+		if (this.config.resourceName) return this.config.resourceName;
+		const clsName = this.constructor.name;
+		if (clsName && clsName !== "Repo") return clsName.replace(/Repo$/i, "") || clsName;
+		const t = this.table.def.name;
+		return t.charAt(0).toUpperCase() + t.slice(1);
+	}
+	get defaultCreateData() {
+		return this.config.defaultCreateData?.() ?? {};
 	}
 	get defaultUpdateData() {
 		return this.config.defaultUpdateData?.() ?? {};
@@ -234,9 +261,6 @@ var Repo = class {
 	transformOutput(item) {
 		return this.config.transformOutput?.(item) ?? item;
 	}
-	transformInput(item) {
-		return this.config.transformInput?.(item) ?? item;
-	}
 	extractKey(item) {
 		const { partitionKey, sortKey } = this.table.def;
 		if (sortKey) return {
@@ -246,40 +270,44 @@ var Repo = class {
 		return { [partitionKey]: item[partitionKey] };
 	}
 	async get(key, options) {
+		const { filter, ...restOptions } = options ?? {};
 		const item = await this.db.get({
 			table: this.tableName,
 			key: this.extractKey(key),
-			...options
+			filter,
+			...restOptions
 		});
 		return item && this.applyTransformIfNeeded(item, options);
 	}
 	async getOrThrow(key, options) {
+		const { filter, ...restOptions } = options ?? {};
 		const item = await this.db.getOrThrow({
 			table: this.tableName,
 			key: this.extractKey(key),
-			...options
+			resource: this.resourceName,
+			filter,
+			...restOptions
 		});
 		return this.applyTransformIfNeeded(item, options);
 	}
 	async put(item, options) {
-		const itemWithDefaults = this.applyPutTransforms(item);
 		const result = await this.db.put({
 			table: this.tableName,
-			item: itemWithDefaults,
+			item,
+			resource: this.resourceName,
 			...options
 		});
 		return this.applyTransformIfNeeded(result);
 	}
 	async update(key, update, options) {
-		const updateWithDefaults = this.applyNormalizersToExpression({
-			...this.defaultUpdateData,
-			...update
-		});
+		const updateWithDefaults = this.applyNormalizersToExpression(update);
 		const result = await this.db.update({
 			table: this.tableName,
 			key: this.extractKey(key),
+			resource: this.resourceName,
 			update: updateWithDefaults,
-			...options
+			...options,
+			condition: this.withDiscriminatorCondition(key, options?.condition)
 		});
 		return this.applyTransformIfNeeded(result);
 	}
@@ -287,15 +315,21 @@ var Repo = class {
 		const { condition: otherCondition, ...otherOptions } = options ?? {};
 		const condition = { $and: [{ [this.table.def.partitionKey]: { $exists: false } }] };
 		if (otherCondition) condition.$and.push(otherCondition);
-		return this.put(item, {
+		const normalizedItem = this.applyCreateTransforms(item);
+		const result = await this.db.put({
+			table: this.tableName,
+			item: normalizedItem,
+			resource: this.resourceName,
 			condition,
 			...otherOptions
 		});
+		return this.applyTransformIfNeeded(result);
 	}
 	async delete(key, options) {
 		const item = await this.db.delete({
 			table: this.tableName,
 			key: this.extractKey(key),
+			resource: this.resourceName,
 			...options
 		});
 		return item && this.applyTransformIfNeeded(item);
@@ -304,6 +338,7 @@ var Repo = class {
 		const item = await this.db.deleteOrThrow({
 			table: this.tableName,
 			key: this.extractKey(key),
+			resource: this.resourceName,
 			...options
 		});
 		return this.applyTransformIfNeeded(item);
@@ -346,6 +381,35 @@ var Repo = class {
 			gsi
 		});
 	}
+	async getGsi(gsi, query, options) {
+		const { filter, ...restOptions } = options ?? {};
+		const items = await this.db.query({
+			table: this.tableName,
+			index: gsi,
+			query,
+			...restOptions
+		});
+		if (items.length > 1) throw new DinahError({
+			type: "DATA_INTEGRITY",
+			message: `getGsi on "${gsi}" returned ${items.length} items; expected at most 1.`
+		});
+		const item = items[0];
+		if (!item) return void 0;
+		if (filter && !require_util.matchesPartial(filter, item)) return void 0;
+		return this.applyTransformIfNeeded(item, {
+			...options,
+			gsi
+		});
+	}
+	async getGsiOrThrow(gsi, query, options) {
+		const item = await this.getGsi(gsi, query, options);
+		if (item === void 0) throw new DinahError({
+			type: "NOT_FOUND",
+			key: query,
+			resource: this.resourceName
+		});
+		return item;
+	}
 	async scan(options) {
 		const items = await this.db.scan({
 			table: this.tableName,
@@ -396,9 +460,11 @@ var Repo = class {
 		});
 	}
 	async batchGet(keys, options) {
+		const { filter, ...restOptions } = options ?? {};
 		const { items, unprocessed } = await this.db.batchGet({ [this.tableName]: {
 			keys: keys.map((key) => this.extractKey(key)),
-			...options
+			filter,
+			...restOptions
 		} });
 		const tableItems = items[this.tableName];
 		return {
@@ -407,9 +473,12 @@ var Repo = class {
 		};
 	}
 	async batchGetOrThrow(keys, options) {
+		const { filter, ...restOptions } = options ?? {};
 		const result = await this.db.batchGetOrThrow({ [this.tableName]: {
 			keys: keys.map((key) => this.extractKey(key)),
-			...options
+			resource: this.resourceName,
+			filter,
+			...restOptions
 		} });
 		return this.applyTransformsIfNeeded(result[this.tableName] ?? [], options);
 	}
@@ -421,7 +490,7 @@ var Repo = class {
 			};
 			else return {
 				type: "PUT",
-				item: this.applyPutTransforms(request.item)
+				item: request.item
 			};
 		}) });
 		return {
@@ -430,27 +499,29 @@ var Repo = class {
 		};
 	}
 	async batchUpdate(keys, update) {
-		const updateWithDefaults = this.applyNormalizersToExpression({
-			...this.defaultUpdateData,
-			...update
-		});
+		const updateWithDefaults = this.applyNormalizersToExpression(update);
 		return { unprocessed: (await this.db.batchUpdate({ [this.tableName]: {
 			keys: keys.map((key) => this.extractKey(key)),
 			update: updateWithDefaults
 		} })).unprocessed?.[this.tableName]?.keys };
 	}
 	async trxGet(keys, options) {
+		const { filter, ...restOptions } = options ?? {};
 		return (await this.db.trxGet(...keys.map((key) => ({
 			table: this.tableName,
 			key: this.extractKey(key),
-			...options
+			filter,
+			...restOptions
 		})))).map((item) => item && this.applyTransformIfNeeded(item, options));
 	}
 	async trxGetOrThrow(keys, options) {
+		const { filter, ...restOptions } = options ?? {};
 		const items = await this.db.trxGetOrThrow(...keys.map((key) => ({
 			table: this.tableName,
 			key: this.extractKey(key),
-			...options
+			resource: this.resourceName,
+			filter,
+			...restOptions
 		})));
 		return this.applyTransformsIfNeeded(items, options);
 	}
@@ -458,8 +529,8 @@ var Repo = class {
 		await this.db.trxWrite(...requests.map((request) => {
 			switch (request.type) {
 				case "CONDITION": {
-					const { key, condition, ...options } = request;
-					return this.trxConditionRequest(key, condition, options);
+					const { key, condition } = request;
+					return this.trxConditionRequest(key, condition);
 				}
 				case "DELETE": {
 					const { key, ...options } = request;
@@ -504,85 +575,125 @@ var Repo = class {
 			...options
 		};
 	}
-	trxConditionRequest(key, condition, options) {
+	trxConditionRequest(key, condition) {
 		return {
 			table: this.tableName,
 			type: "CONDITION",
 			key: this.extractKey(key),
-			condition,
-			...options
+			condition
 		};
 	}
 	trxPutRequest(item, options) {
-		const itemWithDefaults = this.applyPutTransforms(item);
 		return {
 			table: this.tableName,
 			type: "PUT",
-			item: itemWithDefaults,
+			item,
 			...options
 		};
 	}
 	trxUpdateRequest(key, update, options) {
-		const updateWithDefaults = this.applyNormalizersToExpression({
-			...this.defaultUpdateData,
-			...update
-		});
+		const updateWithDefaults = this.applyNormalizersToExpression(update);
 		return {
 			table: this.tableName,
 			type: "UPDATE",
 			key: this.extractKey(key),
 			update: updateWithDefaults,
-			...options
+			...options,
+			condition: this.withDiscriminatorCondition(key, options?.condition)
 		};
 	}
 	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.applyPutTransforms(item);
+		const normalizedItem = this.applyCreateTransforms(item);
 		return {
 			table: this.tableName,
 			type: "PUT",
-			item: itemWithDefaults,
+			item: normalizedItem,
 			condition,
 			...otherOptions
 		};
 	}
-	applyPutTransforms(item) {
-		const result = { ...this.transformInput({
-			...this.defaultPutData,
+	applyCreateTransforms(item) {
+		const { transformAttributes, computedAttributes } = this.config;
+		if (computedAttributes) {
+			for (const key of Object.keys(computedAttributes)) if (key in item) throw new DinahError({
+				type: "VALIDATION",
+				message: `Field "${key}" is a computed attribute and cannot be set directly. Remove it from the create input.`
+			});
+		}
+		const merged = {
+			...this.defaultCreateData,
 			...item
-		}) };
-		for (const key of this.config.derivedAttributes ?? []) delete result[key];
-		return result;
-	}
-	applyNormalizersToExpression(expression) {
-		const partial = {};
-		for (const [key, val] of Object.entries(expression)) if (val === void 0 || isOperation(val) && val.$remove === true) partial[key] = void 0;
-		else if (!isOperation(val)) partial[key] = val;
-		else if (val.$set !== void 0) partial[key] = val.$set;
-		else if (val.$ifNotExists !== void 0) partial[key] = Array.isArray(val.$ifNotExists) ? val.$ifNotExists[1] : val.$ifNotExists;
-		const normalized = this.transformInput(partial);
-		const result = { ...expression };
-		for (const [key, normalizedVal] of Object.entries(normalized)) {
-			if (normalizedVal === void 0) continue;
-			if (key in partial && partial[key] === void 0 || !(key in partial)) result[key] = normalizedVal;
-			else {
-				const original = expression[key];
-				if (!isOperation(original)) result[key] = normalizedVal;
-				else if (original.$set !== void 0) result[key] = {
-					...original,
-					$set: normalizedVal
-				};
-				else if (original.$ifNotExists !== void 0) result[key] = {
-					...original,
-					$ifNotExists: Array.isArray(original.$ifNotExists) ? [original.$ifNotExists[0], normalizedVal] : normalizedVal
+		};
+		if (transformAttributes) {
+			for (const [key, transform] of Object.entries(transformAttributes)) if (key in merged && merged[key] !== void 0) merged[key] = transform(merged[key]);
+		}
+		if (computedAttributes) for (const [key, def] of Object.entries(computedAttributes)) {
+			const { from, compute } = def;
+			const computed = compute(merged[from]);
+			if (computed !== void 0) merged[key] = computed;
+			else delete merged[key];
+		}
+		return merged;
+	}
+	applyNormalizersToExpression(userUpdate) {
+		const { transformAttributes, computedAttributes, immutableAttributes } = this.config;
+		if (computedAttributes) {
+			for (const key of Object.keys(computedAttributes)) if (key in userUpdate) throw new DinahError({
+				type: "VALIDATION",
+				message: `Field "${key}" is a computed attribute and cannot be set directly in an update. Update the source field instead.`
+			});
+		}
+		for (const key of immutableAttributes ?? []) if (key in userUpdate) throw new DinahError({
+			type: "VALIDATION",
+			message: `Field "${key}" is immutable and cannot be updated.`
+		});
+		const result = {
+			...this.defaultUpdateData,
+			...userUpdate
+		};
+		if (transformAttributes) for (const [key, transform] of Object.entries(transformAttributes)) {
+			if (!(key in result)) continue;
+			const val = result[key];
+			const fn = transform;
+			if (val === void 0 || isOperation(val) && val.$remove === true) {} else if (!isOperation(val)) result[key] = fn(val);
+			else if (val.$set !== void 0) result[key] = {
+				...val,
+				$set: fn(val.$set)
+			};
+			else if (val.$ifNotExists !== void 0) {
+				const ifne = val.$ifNotExists;
+				result[key] = {
+					...val,
+					$ifNotExists: Array.isArray(ifne) ? [ifne[0], fn(ifne[1])] : fn(ifne)
 				};
 			}
 		}
-		for (const key of [...this.config.derivedAttributes ?? [], ...this.config.immutableAttributes ?? []]) delete result[key];
+		if (computedAttributes) for (const [computedKey, def] of Object.entries(computedAttributes)) {
+			const { from, compute } = def;
+			if (!(from in result)) continue;
+			const val = result[from];
+			if (val === void 0 || isOperation(val) && val.$remove === true) result[computedKey] = void 0;
+			else if (!isOperation(val)) result[computedKey] = compute(val);
+			else if (val.$set !== void 0) result[computedKey] = compute(val.$set);
+			else throw new DinahError({
+				type: "VALIDATION",
+				message: `Field "${from}" drives computed field "${computedKey}" and cannot use arithmetic or list operators in updates.`
+			});
+		}
 		return result;
 	}
+	withDiscriminatorCondition(key, condition) {
+		const discriminator = this.config.discriminator;
+		if (!discriminator) return condition;
+		const value = key[discriminator];
+		if (value === void 0) return condition;
+		const guard = { [discriminator]: value };
+		if (!condition) return guard;
+		return { $and: [guard, condition] };
+	}
 	applyTransformsIfNeeded(items, options) {
 		if (options?.projection?.length) return items;
 		if (options?.gsi) {
@@ -652,12 +763,16 @@ var Db = class {
 			ExpressionAttributeNames: exp.attributeNames
 		});
 		const output = await this.client.send(input);
-		if (output.Item && data.filter && !data.filter(output.Item)) return;
+		if (output.Item && data.filter && !require_util.matchesPartial(data.filter, 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.`);
+		if (!item) throw new DinahError({
+			type: "NOT_FOUND",
+			key: data.key,
+			resource: data.resource
+		});
 		return item;
 	}
 	async put(data) {
@@ -672,8 +787,16 @@ var Db = class {
 			ExpressionAttributeNames: exp.attributeNames,
 			ExpressionAttributeValues: exp.attributeValues
 		});
-		const output = await this.client.send(input);
-		return data.returnOld ? output.Attributes : item;
+		try {
+			const output = await this.client.send(input);
+			return data.returnOld ? output.Attributes : item;
+		} catch (err) {
+			if (err instanceof _aws_sdk_client_dynamodb.ConditionalCheckFailedException) throw new DinahError({
+				type: "CONDITIONAL_CHECK_FAILED",
+				resource: data.resource
+			}, { cause: err });
+			throw err;
+		}
 	}
 	async update(data) {
 		const exp = new ExpressionBuilder();
@@ -689,7 +812,16 @@ var Db = class {
 			ExpressionAttributeNames: exp.attributeNames,
 			ExpressionAttributeValues: exp.attributeValues
 		});
-		return (await this.client.send(input)).Attributes;
+		try {
+			return (await this.client.send(input)).Attributes;
+		} catch (err) {
+			if (err instanceof _aws_sdk_client_dynamodb.ConditionalCheckFailedException) throw new DinahError({
+				type: "CONDITIONAL_CHECK_FAILED",
+				key: data.key,
+				resource: data.resource
+			}, { cause: err });
+			throw err;
+		}
 	}
 	async delete(data) {
 		const exp = new ExpressionBuilder();
@@ -702,11 +834,24 @@ var Db = class {
 			ExpressionAttributeNames: exp.attributeNames,
 			ExpressionAttributeValues: exp.attributeValues
 		});
-		return (await this.client.send(input)).Attributes;
+		try {
+			return (await this.client.send(input)).Attributes;
+		} catch (err) {
+			if (err instanceof _aws_sdk_client_dynamodb.ConditionalCheckFailedException) throw new DinahError({
+				type: "CONDITIONAL_CHECK_FAILED",
+				key: data.key,
+				resource: data.resource
+			}, { cause: err });
+			throw err;
+		}
 	}
 	async deleteOrThrow(data) {
 		const item = await this.delete(data);
-		if (!item) throw new Error(`Item not found in "${data.table}" table.`);
+		if (!item) throw new DinahError({
+			type: "NOT_FOUND",
+			key: data.key,
+			resource: data.resource
+		});
 		return item;
 	}
 	async *queryPaged(data) {
@@ -821,7 +966,7 @@ var Db = class {
 			const output = await this.client.send(input);
 			for (const [table, items] of Object.entries(output.Responses ?? {})) {
 				if (!result.items[table]) continue;
-				const filteredItems = tableData[table]?.filter ? items.filter(tableData[table].filter) : items;
+				const filteredItems = tableData[table]?.filter ? items.filter((item) => require_util.matchesPartial(tableData[table].filter, item)) : items;
 				result.items[table].push(...filteredItems);
 			}
 			let unprocessedKeyCount = 0;
@@ -863,7 +1008,11 @@ var Db = class {
 		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.`);
+			if (items[table]?.length !== data[table]?.keys?.length) throw new DinahError({
+				type: "NOT_FOUND",
+				key: {},
+				resource: data[table]?.resource
+			});
 		}
 		return items;
 	}
@@ -978,12 +1127,16 @@ var Db = class {
 		return (await this.client.send(input)).Responses?.map((response, i) => {
 			if (!response.Item) return;
 			if (!requests[i]?.filter) return response.Item;
-			return requests[i].filter(response.Item) ? response.Item : void 0;
+			return require_util.matchesPartial(requests[i].filter, response.Item) ? response.Item : void 0;
 		}) ?? [];
 	}
 	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.`);
+		for (let i = 0; i < items.length; i++) if (!items[i]) throw new DinahError({
+			type: "NOT_FOUND",
+			key: requests[i]?.key ?? {},
+			resource: requests[i]?.resource
+		});
 		return items;
 	}
 	async trxWrite(...requests) {
@@ -1013,7 +1166,18 @@ var Db = class {
 			} };
 		});
 		const input = new _aws_sdk_lib_dynamodb.TransactWriteCommand({ TransactItems: trxItems });
-		await this.client.send(input);
+		try {
+			await this.client.send(input);
+		} catch (err) {
+			if (err instanceof _aws_sdk_client_dynamodb.TransactionCanceledException) throw new DinahError({
+				type: "TRANSACTION_CANCELED",
+				reasons: (err.CancellationReasons ?? []).map((r) => ({
+					type: r.Code ?? "Unknown",
+					message: r.Message
+				}))
+			}, { cause: err });
+			throw err;
+		}
 	}
 };
 //#endregion
@@ -1028,11 +1192,14 @@ var Table = class {
 };
 //#endregion
 exports.Db = Db;
+exports.DinahError = DinahError;
 exports.Repo = Repo;
 exports.Table = Table;
 exports.chunk = require_util.chunk;
 exports.extractTableDesc = require_util.extractTableDesc;
+exports.isDinahError = isDinahError;
 exports.makeRepo = makeRepo;
+exports.matchesPartial = require_util.matchesPartial;
 exports.removeUndefined = require_util.removeUndefined;
 exports.resolveAttrType = require_util.resolveAttrType;