dinah 0.2.0 → 0.3.1

package/dist/index.cjs

@@ -1,33 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region \0rolldown/runtime.js
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-//#endregion
+const require_util = require("./util-BOJ7V5_l.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 = __toESM(_aws_sdk_lib_dynamodb);
+_aws_sdk_lib_dynamodb = require_util.__toESM(_aws_sdk_lib_dynamodb);
 let sift = require("sift");
-sift = __toESM(sift);
-let typebox = require("typebox");
-typebox = __toESM(typebox);
+sift = require_util.__toESM(sift);
 //#region src/expression-builder.ts
 const attrTypes = [
 	"S",
@@ -208,18 +185,22 @@ var ExpressionBuilder = class {
 };
 //#endregion
 //#region src/repo.ts
-var Repository = class {
-	table;
+var AbstractRepo = class {
 	db;
-	constructor(table, db) {
-		this.table = table;
+	constructor(db) {
 		this.db = db;
 	}
 	get tableName() {
 		return `${this.db.config?.tableNamePrefix ?? ""}${this.table.def.name}`;
 	}
-	get def() {
-		return this.table.def;
+	get defaultPutData() {
+		return {};
+	}
+	get defaultUpdateData() {
+		return {};
+	}
+	transformItem(item) {
+		return item;
 	}
 	extractKey(item) {
 		const { partitionKey, sortKey } = this.table.def;
@@ -230,140 +211,141 @@ var Repository = class {
 		return { [partitionKey]: item[partitionKey] };
 	}
 	async get(key, options) {
-		return this.db.get({
+		const item = await this.db.get({
 			table: this.tableName,
 			key: this.extractKey(key),
 			...options
 		});
+		return item && this.applyTransformIfNeeded(item, options);
 	}
 	async getOrThrow(key, options) {
-		return this.db.getOrThrow({
+		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.table.def.beforePut ? {
-			...this.table.def.beforePut(item),
+		const itemWithDefaults = {
+			...this.defaultPutData,
 			...item
-		} : item;
-		return this.db.put({
+		};
+		const result = await this.db.put({
 			table: this.tableName,
 			item: itemWithDefaults,
 			...options
 		});
+		return this.applyTransformIfNeeded(result);
 	}
 	async update(key, update, options) {
-		const updateWithDefaults = this.table.def.beforeUpdate ? {
-			...this.table.def.beforeUpdate(update),
+		const updateWithDefaults = {
+			...this.defaultUpdateData,
 			...update
-		} : update;
-		return this.db.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 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
+		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) {
-		return this.db.delete({
+		const item = await this.db.delete({
 			table: this.tableName,
 			key: this.extractKey(key),
 			...options
 		});
+		return item && this.applyTransformIfNeeded(item);
 	}
 	async deleteOrThrow(key, options) {
-		return this.db.deleteOrThrow({
+		const item = await this.db.deleteOrThrow({
 			table: this.tableName,
 			key: this.extractKey(key),
 			...options
 		});
+		return this.applyTransformIfNeeded(item);
 	}
 	async query(query, options) {
-		return this.db.query({
+		const items = await this.db.query({
 			table: this.tableName,
 			query,
 			...options
 		});
+		return this.applyTransformsIfNeeded(items, options);
 	}
 	async *queryPaged(query, options) {
-		yield* this.db.queryPaged({
+		for await (const page of this.db.queryPaged({
 			table: this.tableName,
 			query,
 			...options
-		});
+		})) yield this.applyTransformsIfNeeded(page, options);
 	}
 	async queryGsi(gsi, query, options) {
-		return this.db.query({
+		const items = await this.db.query({
 			table: this.tableName,
 			index: gsi,
 			query,
 			...options
 		});
+		return this.applyTransformsIfNeeded(items, {
+			...options,
+			gsi
+		});
 	}
 	async *queryGsiPaged(gsi, query, options) {
-		yield* this.db.queryPaged({
+		for await (const page of this.db.queryPaged({
 			table: this.tableName,
 			index: gsi,
 			query,
 			...options
+		})) yield this.applyTransformsIfNeeded(page, {
+			...options,
+			gsi
 		});
 	}
 	async scan(options) {
-		return this.db.scan({
+		const items = await this.db.scan({
 			table: this.tableName,
 			...options
 		});
+		return this.applyTransformsIfNeeded(items, options);
 	}
 	async *scanPaged(options) {
-		yield* this.db.scanPaged({
+		for await (const page of this.db.scanPaged({
 			table: this.tableName,
 			...options
-		});
+		})) yield this.applyTransformsIfNeeded(page, options);
 	}
 	async scanGsi(gsi, options) {
-		return this.db.scan({
+		const items = await this.db.scan({
 			table: this.tableName,
 			index: gsi,
 			...options
 		});
+		return this.applyTransformsIfNeeded(items, {
+			...options,
+			gsi
+		});
 	}
 	async *scanGsiPaged(gsi, options) {
-		yield* this.db.scanPaged({
+		for await (const page of this.db.scanPaged({
 			table: this.tableName,
 			index: gsi,
 			...options
+		})) yield this.applyTransformsIfNeeded(page, {
+			...options,
+			gsi
 		});
 	}
 	async exists(options) {
@@ -386,16 +368,18 @@ var Repository = class {
 			keys: keys.map((key) => this.extractKey(key)),
 			...options
 		} });
+		const tableItems = items[this.tableName];
 		return {
-			items: items[this.tableName],
+			items: tableItems && this.applyTransformsIfNeeded(tableItems, options),
 			unprocessed: unprocessed?.[this.tableName]?.keys
 		};
 	}
 	async batchGetOrThrow(keys, options) {
-		return (await this.db.batchGetOrThrow({ [this.tableName]: {
+		const result = await this.db.batchGetOrThrow({ [this.tableName]: {
 			keys: keys.map((key) => this.extractKey(key)),
 			...options
-		} }))[this.tableName];
+		} });
+		return this.applyTransformsIfNeeded(result[this.tableName] ?? [], options);
 	}
 	async batchWrite(requests) {
 		const { items, unprocessed } = await this.db.batchWrite({ [this.tableName]: requests.map((request) => {
@@ -405,10 +389,10 @@ var Repository = class {
 			};
 			else return {
 				type: "PUT",
-				item: this.table.def.beforePut ? {
-					...this.table.def.beforePut(request.item),
+				item: {
+					...this.defaultPutData,
 					...request.item
-				} : request.item
+				}
 			};
 		}) });
 		return {
@@ -417,18 +401,19 @@ var Repository = class {
 		};
 	}
 	async trxGet(keys, options) {
-		return this.db.trxGet(...keys.map((key) => ({
+		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) {
-		return this.db.trxGetOrThrow(...keys.map((key) => ({
+		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) => {
@@ -490,10 +475,10 @@ var Repository = class {
 		};
 	}
 	trxPutRequest(item, options) {
-		const itemWithDefaults = this.table.def.beforePut ? {
-			...this.table.def.beforePut(item),
+		const itemWithDefaults = {
+			...this.defaultPutData,
 			...item
-		} : item;
+		};
 		return {
 			table: this.tableName,
 			type: "PUT",
@@ -502,10 +487,10 @@ var Repository = class {
 		};
 	}
 	trxUpdateRequest(key, update, options) {
-		const updateWithDefaults = this.table.def.beforeUpdate ? {
-			...this.table.def.beforeUpdate(update),
+		const updateWithDefaults = {
+			...this.defaultUpdateData,
 			...update
-		} : update;
+		};
 		return {
 			table: this.tableName,
 			type: "UPDATE",
@@ -518,10 +503,10 @@ var Repository = class {
 		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),
+		const itemWithDefaults = {
+			...this.defaultPutData,
 			...item
-		} : item;
+		};
 		return {
 			table: this.tableName,
 			type: "PUT",
@@ -530,78 +515,25 @@ var Repository = class {
 			...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;
+	}
 };
-//#endregion
-//#region src/util.ts
-const resolveAttrType = (schema, attrName) => {
-	if (typebox.IsString(schema) || typebox.IsLiteralString(schema)) return typebox.IsOptional(schema) ? ["S", void 0] : ["S"];
-	if (typebox.IsNumber(schema) || typebox.IsLiteralNumber(schema)) return typebox.IsOptional(schema) ? ["N", void 0] : ["N"];
-	if (typebox.IsObject(schema)) {
-		const attrSchema = schema.properties[attrName];
-		if (!attrSchema) return [void 0];
-		return resolveAttrType(attrSchema, attrName);
-	}
-	if (typebox.IsIntersect(schema)) return schema.allOf.flatMap((s) => resolveAttrType(s, attrName));
-	if (typebox.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];
-		});
+var Repo = class extends AbstractRepo {
+	table;
+	constructor(db, table) {
+		super(db);
+		this.table = table;
 	}
-	return obj;
 };
 //#endregion
 //#region src/db.ts
@@ -620,7 +552,13 @@ var Db = class {
 		this.config = dbConfig;
 	}
 	createRepo(table) {
-		return new Repository(table, this);
+		return new Repo(this, table);
+	}
+	async createTable(table) {
+		await this.client.send(new _aws_sdk_client_dynamodb.CreateTableCommand(require_util.extractTableDesc(table)));
+	}
+	async deleteTable(tableName) {
+		await this.client.send(new _aws_sdk_client_dynamodb.DeleteTableCommand({ TableName: tableName }));
 	}
 	async listTables(data) {
 		const tables = [];
@@ -657,17 +595,18 @@ var Db = class {
 	}
 	async put(data) {
 		const exp = new ExpressionBuilder();
+		const item = require_util.removeUndefined(data.item);
 		const input = new _aws_sdk_lib_dynamodb.PutCommand({
 			TableName: data.table,
-			Item: removeUndefined(data.item),
-			ReturnValues: data.return === "ALL_OLD" ? "ALL_OLD" : void 0,
+			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.return === "ALL_OLD" ? output.Attributes : data;
+		return data.returnOld ? output.Attributes : item;
 	}
 	async update(data) {
 		const exp = new ExpressionBuilder();
@@ -676,7 +615,7 @@ var Db = class {
 		const input = new _aws_sdk_lib_dynamodb.UpdateCommand({
 			TableName: data.table,
 			Key: data.key,
-			ReturnValues: data.return ?? "ALL_NEW",
+			ReturnValues: "ALL_NEW",
 			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
 			UpdateExpression: exp.update(data.update),
 			ConditionExpression: exp.condition(condition),
@@ -685,40 +624,12 @@ var Db = class {
 		});
 		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 _aws_sdk_client_dynamodb.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 _aws_sdk_lib_dynamodb.DeleteCommand({
 			TableName: data.table,
 			Key: data.key,
-			ReturnValues: data.return ?? "ALL_OLD",
+			ReturnValues: "ALL_OLD",
 			ConditionExpression: exp.condition(data.condition),
 			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
 			ExpressionAttributeNames: exp.attributeNames,
@@ -972,7 +883,7 @@ var Db = class {
 			} };
 			if (request.type === "PUT") return { Put: {
 				TableName: request.table,
-				Item: removeUndefined(request.item),
+				Item: require_util.removeUndefined(request.item),
 				ConditionExpression: exp.condition(request.condition),
 				ExpressionAttributeNames: exp.attributeNames,
 				ExpressionAttributeValues: exp.attributeValues
@@ -999,83 +910,15 @@ var Table = class {
 		this.schema = schema;
 		this.def = def;
 	}
-	async drop(client) {
-		await client.send(new _aws_sdk_client_dynamodb.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 _aws_sdk_client_dynamodb.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 _aws_sdk_client_dynamodb.UpdateTimeToLiveCommand({
-			TableName: desc.tableName,
-			TimeToLiveSpecification: {
-				Enabled: true,
-				AttributeName: desc.ttlAttribute
-			}
-		}));
-	}
 };
 //#endregion
+exports.AbstractRepo = AbstractRepo;
 exports.Db = Db;
-exports.Repository = Repository;
+exports.Repo = Repo;
 exports.Table = Table;
-exports.__toESM = __toESM;
-exports.chunk = chunk;
-exports.extractAttribute = extractAttribute;
-exports.extractTableDesc = extractTableDesc;
-exports.extractTableKey = extractTableKey;
-exports.getAttrType = getAttrType;
-exports.removeUndefined = removeUndefined;
-exports.resolveAttrType = resolveAttrType;
+exports.chunk = require_util.chunk;
+exports.extractTableDesc = require_util.extractTableDesc;
+exports.removeUndefined = require_util.removeUndefined;
+exports.resolveAttrType = require_util.resolveAttrType;
 
 //# sourceMappingURL=index.cjs.map