dinah 0.2.0 → 0.3.1

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { ConditionalCheckFailedException, CreateTableCommand, DeleteTableCommand, DynamoDB, DynamoDBClient, ListTablesCommand, UpdateTimeToLiveCommand } from "@aws-sdk/client-dynamodb";
+import { i as resolveAttrType, n as extractTableDesc, r as removeUndefined, t as chunk } from "./util-B4dDuxlC.mjs";
+import { CreateTableCommand, DeleteTableCommand, DynamoDB, DynamoDBClient, ListTablesCommand } 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",
@@ -182,18 +182,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;
@@ -204,140 +208,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) {
@@ -360,16 +365,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) => {
@@ -379,10 +386,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 {
@@ -391,18 +398,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) => {
@@ -464,10 +472,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",
@@ -476,10 +484,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",
@@ -492,10 +500,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",
@@ -504,78 +512,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 (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];
-		});
+var Repo = class extends AbstractRepo {
+	table;
+	constructor(db, table) {
+		super(db);
+		this.table = table;
 	}
-	return obj;
 };
 //#endregion
 //#region src/db.ts
@@ -594,7 +549,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 CreateTableCommand(extractTableDesc(table)));
+	}
+	async deleteTable(tableName) {
+		await this.client.send(new DeleteTableCommand({ TableName: tableName }));
 	}
 	async listTables(data) {
 		const tables = [];
@@ -631,17 +592,18 @@ var Db = class {
 	}
 	async put(data) {
 		const exp = new ExpressionBuilder();
+		const item = removeUndefined(data.item);
 		const input = new Lib.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();
@@ -650,7 +612,7 @@ var Db = class {
 		const input = new Lib.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),
@@ -659,40 +621,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 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",
+			ReturnValues: "ALL_OLD",
 			ConditionExpression: exp.condition(data.condition),
 			ReturnValuesOnConditionCheckFailure: "ALL_OLD",
 			ExpressionAttributeNames: exp.attributeNames,
@@ -973,73 +907,8 @@ var Table = class {
 		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 };
+export { AbstractRepo, Db, Repo, Table, chunk, extractTableDesc, removeUndefined, resolveAttrType };
 
 //# sourceMappingURL=index.mjs.map