dyno-table 0.0.1 → 0.0.2

package/dist/index.js

@@ -1,34 +1,3 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  BaseRepository: () => BaseRepository,
-  ConditionalCheckFailedError: () => ConditionalCheckFailedError,
-  DynamoError: () => DynamoError,
-  ExponentialBackoffStrategy: () => ExponentialBackoffStrategy,
-  ResourceNotFoundError: () => ResourceNotFoundError,
-  Table: () => Table
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/builders/expression-builder.ts
 var ExpressionBuilder = class {
   nameCount = 0;
@@ -98,10 +67,7 @@ var ExpressionBuilder = class {
       attributes: this.formatAttributes(attributes)
     };
   }
-  formatAttributes({
-    names,
-    values
-  }) {
+  formatAttributes({ names, values }) {
     return {
       ...Object.keys(names).length && { names },
       ...Object.keys(values).length && { values }
@@ -118,18 +84,9 @@ var ExpressionBuilder = class {
       const skName = this.generateAlias("name", "sk");
       attributes.names[skName] = indexConfig.skName;
       if (typeof key.sk === "string") {
-        conditions.push(
-          `${skName} = ${this.addValue(attributes, key.sk, "sk")}`
-        );
+        conditions.push(`${skName} = ${this.addValue(attributes, key.sk, "sk")}`);
       } else {
-        conditions.push(
-          this.buildComparison(
-            skName,
-            key.sk.operator,
-            key.sk.value,
-            attributes
-          )
-        );
+        conditions.push(this.buildComparison(skName, key.sk.operator, key.sk.value, attributes));
       }
     }
     return {
@@ -192,6 +149,39 @@ var OperationBuilder = class {
   whereIn(field, values) {
     return this.where(field, "IN", values);
   }
+  whereLessThan(field, value) {
+    return this.where(field, "<", value);
+  }
+  whereLessThanOrEqual(field, value) {
+    return this.where(field, "<=", value);
+  }
+  whereGreaterThan(field, value) {
+    return this.where(field, ">", value);
+  }
+  whereGreaterThanOrEqual(field, value) {
+    return this.where(field, ">=", value);
+  }
+  whereNotEqual(field, value) {
+    return this.where(field, "<>", value);
+  }
+  whereBeginsWith(field, value) {
+    return this.where(field, "begins_with", value);
+  }
+  whereContains(field, value) {
+    return this.where(field, "contains", value);
+  }
+  whereNotContains(field, value) {
+    this.conditions.push({ field, operator: "not_contains", value });
+    return this;
+  }
+  whereAttributeType(field, value) {
+    this.conditions.push({ field, operator: "attribute_type", value });
+    return this;
+  }
+  whereSize(field, value) {
+    this.conditions.push({ field, operator: "size", value });
+    return this;
+  }
   buildConditionExpression() {
     return this.expressionBuilder.createExpression(this.conditions);
   }
@@ -201,8 +191,17 @@ var OperationBuilder = class {
 var PutBuilder = class extends OperationBuilder {
   constructor(item, expressionBuilder, onBuild) {
     super(expressionBuilder);
-    this.item = item;
     this.onBuild = onBuild;
+    this.item = item;
+  }
+  item;
+  set(field, value) {
+    this.item[field] = value;
+    return this;
+  }
+  setMany(attributes) {
+    this.item = { ...this.item, ...attributes };
+    return this;
   }
   build() {
     const { expression, attributes } = this.buildConditionExpression();
@@ -216,6 +215,11 @@ var PutBuilder = class extends OperationBuilder {
       } : void 0
     };
   }
+  /**
+   * Runs the put operation to insert the provided attributes into the table.
+   *
+   * @returns The provided attributes. This does not load the model from the DB after insert
+   */
   async execute() {
     return this.onBuild(this.build());
   }
@@ -241,10 +245,7 @@ var QueryBuilder = class extends OperationBuilder {
   }
   build() {
     const filter = this.buildConditionExpression();
-    const keyCondition = this.expressionBuilder.buildKeyCondition(
-      this.key,
-      this.indexConfig
-    );
+    const keyCondition = this.expressionBuilder.buildKeyCondition(this.key, this.indexConfig);
     return {
       type: "query",
       keyCondition: {
@@ -278,8 +279,8 @@ var UpdateBuilder = class extends OperationBuilder {
     this.updates[field] = value;
     return this;
   }
-  setMany(attribtues) {
-    this.updates = { ...this.updates, ...attribtues };
+  setMany(attributes) {
+    this.updates = { ...this.updates, ...attributes };
     return this;
   }
   remove(...fields) {
@@ -351,10 +352,7 @@ function translateExpression(expression, attributes) {
   }
   if (attributes.values) {
     for (const [alias, value] of Object.entries(attributes.values)) {
-      translated = translated.replace(
-        new RegExp(alias, "g"),
-        typeof value === "string" ? `"${value}"` : String(value)
-      );
+      translated = translated.replace(new RegExp(alias, "g"), typeof value === "string" ? `"${value}"` : String(value));
     }
   }
   return translated;
@@ -372,28 +370,20 @@ Key: ${JSON.stringify(context.key, null, 2)}`);
   if (context.expression) {
     const { condition, update, filter, keyCondition } = context.expression;
     if (condition) {
-      parts.push(
-        `
-Condition: ${translateExpression(condition, context.attributes)}`
-      );
+      parts.push(`
+Condition: ${translateExpression(condition, context.attributes)}`);
     }
     if (update) {
-      parts.push(
-        `
-Update: ${translateExpression(update, context.attributes)}`
-      );
+      parts.push(`
+Update: ${translateExpression(update, context.attributes)}`);
     }
     if (filter) {
-      parts.push(
-        `
-Filter: ${translateExpression(filter, context.attributes)}`
-      );
+      parts.push(`
+Filter: ${translateExpression(filter, context.attributes)}`);
     }
     if (keyCondition) {
-      parts.push(
-        `
-Key Condition: ${translateExpression(keyCondition, context.attributes)}`
-      );
+      parts.push(`
+Key Condition: ${translateExpression(keyCondition, context.attributes)}`);
     }
   }
   parts.push(`
@@ -682,7 +672,10 @@ var DynamoService = class {
   async put(options) {
     try {
       const params = this.converter.toPutCommand(options);
-      return await this.withRetry(() => this.client.put(params));
+      return await this.withRetry(async () => {
+        await this.client.put(params);
+        return options.item;
+      });
     } catch (error) {
       handleDynamoError(error, {
         operation: "PUT",
@@ -772,9 +765,7 @@ var DynamoService = class {
   async batchWrite(items) {
     try {
       const chunks = this.chunkArray(items, BATCH_WRITE_LIMIT);
-      return await Promise.all(
-        chunks.map((chunk) => this.processBatchWrite(chunk))
-      );
+      return await Promise.all(chunks.map((chunk) => this.processBatchWrite(chunk)));
     } catch (error) {
       handleDynamoError(error, {
         operation: "BATCH_WRITE",
@@ -784,9 +775,7 @@ var DynamoService = class {
   }
   async transactWrite(items) {
     if (items.length > TRANSACTION_LIMIT) {
-      throw new Error(
-        `Transaction limit exceeded. Maximum is ${TRANSACTION_LIMIT} items, got ${items.length}`
-      );
+      throw new Error(`Transaction limit exceeded. Maximum is ${TRANSACTION_LIMIT} items, got ${items.length}`);
     }
     try {
       const params = this.converter.toTransactWriteCommand(items);
@@ -823,10 +812,9 @@ var DynamoService = class {
     const processUnprocessedItems = async (unprocessedItems2) => {
       const params2 = this.converter.toBatchWriteCommand(unprocessedItems2);
       const result = await this.client.batchWrite(params2);
-      if (result.UnprocessedItems?.[this.tableName]?.length) {
-        const remainingItems = this.converter.fromBatchWriteResponse(
-          result.UnprocessedItems[this.tableName]
-        );
+      const outstandingItems = result.UnprocessedItems?.[this.tableName];
+      if (outstandingItems && outstandingItems.length > 0) {
+        const remainingItems = this.converter.fromBatchWriteResponse(outstandingItems);
         throw {
           name: "UnprocessedItemsError",
           unprocessedItems: remainingItems
@@ -836,12 +824,11 @@ var DynamoService = class {
     };
     const params = this.converter.toBatchWriteCommand(items);
     const initialResult = await this.client.batchWrite(params);
-    if (!initialResult.UnprocessedItems?.[this.tableName]?.length) {
+    const rawUnprocessedItems = initialResult.UnprocessedItems?.[this.tableName];
+    if (!rawUnprocessedItems || rawUnprocessedItems.length === 0) {
       return initialResult;
     }
-    const unprocessedItems = this.converter.fromBatchWriteResponse(
-      initialResult.UnprocessedItems[this.tableName]
-    );
+    const unprocessedItems = this.converter.fromBatchWriteResponse(rawUnprocessedItems);
     return this.withRetry(() => processUnprocessedItems(unprocessedItems));
   }
   async withRetry(operation, strategy = new ExponentialBackoffStrategy()) {
@@ -853,9 +840,7 @@ var DynamoService = class {
         if (!strategy.shouldRetry(error, attempt)) {
           throw error;
         }
-        await new Promise(
-          (resolve) => setTimeout(resolve, strategy.getDelay(attempt))
-        );
+        await new Promise((resolve) => setTimeout(resolve, strategy.getDelay(attempt)));
         attempt++;
       }
     }
@@ -868,6 +853,46 @@ var DynamoService = class {
   }
 };
 
+// src/builders/scan-builder.ts
+var ScanBuilder = class extends OperationBuilder {
+  constructor(expressionBuilder, onBuild) {
+    super(expressionBuilder);
+    this.onBuild = onBuild;
+  }
+  limitValue;
+  indexNameValue;
+  pageKeyValue;
+  limit(value) {
+    this.limitValue = value;
+    return this;
+  }
+  useIndex(indexName) {
+    this.indexNameValue = indexName;
+    return this;
+  }
+  startKey(key) {
+    this.pageKeyValue = key;
+    return this;
+  }
+  build() {
+    const filter = this.buildConditionExpression();
+    return {
+      type: "scan",
+      filter: filter.expression ? {
+        expression: filter.expression,
+        names: filter.attributes.names,
+        values: filter.attributes.values
+      } : void 0,
+      limit: this.limitValue,
+      pageKey: this.pageKeyValue,
+      indexName: this.indexNameValue
+    };
+  }
+  async execute() {
+    return this.onBuild(this.build());
+  }
+};
+
 // src/table.ts
 var Table = class {
   dynamoService;
@@ -893,18 +918,10 @@ var Table = class {
     throw new Error(`Index ${indexName} does not exist`);
   }
   put(item) {
-    return new PutBuilder(
-      item,
-      this.expressionBuilder,
-      (operation) => this.executeOperation(operation)
-    );
+    return new PutBuilder(item, this.expressionBuilder, (operation) => this.executeOperation(operation));
   }
   update(key, data) {
-    const builder = new UpdateBuilder(
-      key,
-      this.expressionBuilder,
-      (operation) => this.executeOperation(operation)
-    );
+    const builder = new UpdateBuilder(key, this.expressionBuilder, (operation) => this.executeOperation(operation));
     if (data) {
       builder.setMany(data);
     }
@@ -931,22 +948,8 @@ var Table = class {
     };
     return this.executeOperation(operation);
   }
-  async scan(filters, options) {
-    let filter = void 0;
-    if (filters?.length) {
-      const filterResult = this.expressionBuilder.createExpression(filters);
-      filter = {
-        expression: filterResult.expression,
-        names: filterResult.attributes.names,
-        values: filterResult.attributes.values
-      };
-    }
-    return this.dynamoService.scan({
-      filter,
-      limit: options?.limit,
-      pageKey: options?.pageKey,
-      indexName: options?.indexName
-    });
+  scan() {
+    return new ScanBuilder(this.expressionBuilder, (operation) => this.executeOperation(operation));
   }
   async batchWrite(operations) {
     const batchOperation = {
@@ -996,6 +999,13 @@ var Table = class {
         return this.dynamoService.batchWrite(operation.operations);
       case "transactWrite":
         return this.dynamoService.transactWrite(operation.operations);
+      case "scan":
+        return this.dynamoService.scan({
+          filter: operation.filter,
+          limit: operation.limit,
+          pageKey: operation.pageKey,
+          indexName: operation.indexName
+        });
       default:
         throw new Error("Unknown operation type");
     }
@@ -1025,59 +1035,143 @@ var Table = class {
 
 // src/repository/base-repository.ts
 var BaseRepository = class {
-  constructor(table, schema) {
+  constructor(table) {
     this.table = table;
-    this.schema = schema;
   }
+  /**
+   * Hook method called before inserting a record.
+   * Subclasses can override this method to modify the data before insertion.
+   * @param data - The record data.
+   * @returns The modified record data.
+   */
   beforeInsert(data) {
     return data;
   }
+  /**
+   * Hook method called before updating a record.
+   * Subclasses can override this method to modify the data before updating.
+   * @param data - The partial record data to be updated.
+   * @returns The modified partial record data.
+   */
   beforeUpdate(data) {
     return data;
   }
-  async create(data) {
-    const parsed = this.schema.parse(data);
-    const key = this.createPrimaryKey(parsed);
+  /**
+   * Checks if a record exists in the table.
+   * @param key - The primary key of the record.
+   * @returns A promise that resolves to true if the record exists, false otherwise.
+   */
+  async exists(key) {
+    const item = await this.table.get(key);
+    return item !== null;
+  }
+  /**
+   * Type guard to check if the value is a primary key.
+   * @param value - The value to check.
+   * @returns True if the value is a primary key, false otherwise.
+   */
+  isPrimaryKey(value) {
+    return "pk" in value && typeof value.pk === "string";
+  }
+  /**
+   * Creates a new record in the table.
+   * @param data - The record data.
+   * @returns A PutBuilder instance to execute the put operation.
+   */
+  create(data) {
+    const key = this.createPrimaryKey(data);
     const item = {
-      ...parsed,
+      ...data,
       ...key
     };
     const indexConfig = this.table.getIndexConfig();
-    await this.table.put(item).whereNotExists(indexConfig.pkName).execute();
-    return parsed;
+    const builder = this.table.put(item).set(this.getTypeAttributeName(), this.getType()).whereNotExists(indexConfig.pkName);
+    if (indexConfig.skName) {
+      builder.whereNotExists(indexConfig.skName);
+    }
+    return builder;
   }
+  /**
+   * Updates an existing record in the table.
+   * @param key - The primary key of the record.
+   * @param updates - The partial record data to be updated.
+   * @returns A promise that resolves to the updated record or null if the record does not exist.
+   */
   async update(key, updates) {
-    const parsed = this.schema.parse(updates);
-    const result = await this.table.update(key).setMany(parsed).execute();
-    return result.Attributes ? this.schema.parse(result.Attributes) : null;
+    const processed = this.beforeUpdate(updates);
+    const updateData = {
+      ...processed,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const result = await this.table.update(key).setMany(updateData).execute();
+    if (!result.Attributes) return null;
+    return this.findOne(key);
   }
-  async delete(key) {
+  /**
+   * Upserts (inserts or updates) a record in the table.
+   * @param data - The record data.
+   * @returns A PutBuilder instance to execute the put operation.
+   */
+  upsert(data) {
+    const key = this.createPrimaryKey(data);
+    return this.table.put({
+      ...data,
+      ...key
+    });
+  }
+  /**
+   * Deletes a record from the table.
+   * @param keyOrDTO - The primary key or the record data.
+   * @returns A promise that resolves when the record is deleted.
+   */
+  async delete(keyOrDTO) {
+    if (this.isPrimaryKey(keyOrDTO)) {
+      this.table.delete(keyOrDTO);
+      return;
+    }
+    const key = this.createPrimaryKey(keyOrDTO);
     await this.table.delete(key);
   }
+  /**
+   * Finds a single record by its primary key.
+   * @param key - The primary key of the record.
+   * @returns A promise that resolves to the record or null if the record does not exist.
+   */
   async findOne(key) {
-    const item = await this.table.query(key).where(this.getTypeAttributeName(), "=", this.getType()).execute();
+    const results = await this.table.query(key).whereEquals(this.getTypeAttributeName(), this.getType()).limit(1).execute();
+    const item = results.Items?.[0];
     if (!item) {
       return null;
     }
-    return this.schema.parse(item);
+    return item;
   }
+  /**
+   * Finds a single record by its primary key or throws an error if the record does not exist.
+   * @param key - The primary key of the record.
+   * @returns A promise that resolves to the record.
+   * @throws An error if the record does not exist.
+   */
   async findOrFail(key) {
     const result = await this.findOne(key);
     if (!result) {
       throw new Error("Item not found");
     }
-    return this.schema.parse(result);
+    return result;
   }
+  /**
+   * Creates a query builder for querying records by their primary key.
+   * @param key - The primary key of the record.
+   * @returns A QueryBuilder instance to build and execute the query.
+   */
   query(key) {
-    return this.table.query(key).where(this.getTypeAttributeName(), "=", this.getType());
+    return this.table.query(key).whereEquals(this.getTypeAttributeName(), this.getType());
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   BaseRepository,
   ConditionalCheckFailedError,
   DynamoError,
   ExponentialBackoffStrategy,
   ResourceNotFoundError,
   Table
-});
+};

package/package.json

@@ -1,16 +1,25 @@
 {
   "name": "dyno-table",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "A TypeScript library to simplify working with DynamoDB",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "type": "commonjs",
+  "type": "module",
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
       "require": "./dist/index.js"
     }
   },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "clean": "rm -rf dist",
+    "test": "vitest",
+    "test:int": "vitest --config vitest.integration.ts",
+    "lint": "biome lint",
+    "check-types": "tsc --noEmit",
+    "ddb:start": "docker compose up -d dynamodb"
+  },
   "keywords": [
     "dynamodb",
     "aws",
@@ -24,28 +33,19 @@
     "url": "git+https://github.com/Kysumi/dyno-table.git"
   },
   "devDependencies": {
+    "@babel/preset-typescript": "^7.26.0",
     "@biomejs/biome": "1.9.4",
     "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "vitest": "^2.1.8",
     "rimraf": "^5.0.0",
-    "tsup": "^8.0.0"
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.1.8"
   },
   "peerDependencies": {
     "@aws-sdk/client-dynamodb": "^3.0.0",
-    "@aws-sdk/lib-dynamodb": "^3.0.0",
-    "zod": "^3.0.0"
+    "@aws-sdk/lib-dynamodb": "^3.0.0"
   },
   "files": [
     "dist"
-  ],
-  "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "clean": "rm -rf dist",
-    "test": "vitest",
-    "test:int": "vitest --config vitest.integration.ts",
-    "lint": "biome lint",
-    "check-types": "tsc --noEmit",
-    "ddb:start": "docker compose up -d dynamodb"
-  }
-}
+  ]
+}