@aurios/mizzle 1.1.2 → 1.1.4

package/src/builders/delete.ts

@@ -1,71 +1,64 @@
 import { DeleteCommand } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@repo/shared";
 import { Entity, type InferSelectModel } from "../core/table";
 import { BaseBuilder } from "./base";
 import { type IMizzleClient } from "../core/client";
 import { type Expression } from "../expressions/operators";
 
 export class DeleteBuilder<
-    TEntity extends Entity,
-    TResult = InferSelectModel<TEntity>,
+  TEntity extends Entity,
+  TResult = InferSelectModel<TEntity>,
 > extends BaseBuilder<TEntity, TResult> {
-    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "DeleteBuilder";
+  static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "DeleteBuilder";
 
-    private _returnValues?: "NONE" | "ALL_OLD";
-    private _keys: Record<string, unknown>;
+  private _returnValues?: "NONE" | "ALL_OLD";
+  private _keys: Record<string, unknown>;
 
-    constructor(
-        entity: TEntity,
-        client: IMizzleClient,
-        keys: Record<string, unknown>,
-    ) {
-        super(entity, client);
-        this._keys = keys;
-    }
+  constructor(entity: TEntity, client: IMizzleClient, keys: Record<string, unknown>) {
+    super(entity, client);
+    this._keys = keys;
+  }
 
-    /**
-     * Instructs Mizzle to return the deleted item after execution.
-     * 
-     * @returns The current builder instance.
-     */
-    returning(): this {
-        this._returnValues = "ALL_OLD";
-        return this;
-    }
+  /**
+   * Instructs Mizzle to return the deleted item after execution.
+   *
+   * @returns The current builder instance.
+   */
+  returning(): this {
+    this._returnValues = "ALL_OLD";
+    return this;
+  }
 
-    /** @internal */
-    get keys() {
-        return this._keys;
-    }
+  /** @internal */
+  get keys() {
+    return this._keys;
+  }
 
-    /** @internal */
-    public override resolveKeys(
-        whereClause?: Expression,
-        providedValues?: Record<string, unknown>,
-    ) {
-        return super.resolveKeys(whereClause, providedValues);
-    }
+  /** @internal */
+  public override resolveKeys(whereClause?: Expression, providedValues?: Record<string, unknown>) {
+    return super.resolveKeys(whereClause, providedValues);
+  }
 
-    /** @internal */
-    public override createExpressionContext(prefix = "") {
-        return super.createExpressionContext(prefix);
-    }
+  /** @internal */
+  public override createExpressionContext(prefix = "") {
+    return super.createExpressionContext(prefix);
+  }
 
-    /**
-     * Executes the delete operation.
-     * 
-     * @returns A promise that resolves to the deleted item if `.returning()` was called, otherwise undefined.
-     */
-    public override async execute(): Promise<TResult> {
-        const resolution = this.resolveKeys(undefined, this._keys);
+  /**
+   * Executes the delete operation.
+   *
+   * @returns A promise that resolves to the deleted item if `.returning()` was called, otherwise undefined.
+   */
+  public override async execute(): Promise<TResult> {
+    const resolution = this.resolveKeys(undefined, this._keys);
 
-        const command = new DeleteCommand({
-            TableName: this.tableName,
-            Key: resolution.keys,
-            ReturnValues: this._returnValues,
-        });
+    const command = new DeleteCommand({
+      TableName: this.tableName,
+      Key: resolution.keys,
+      ReturnValues: this._returnValues,
+    });
 
-        const response = await this.client.send(command) as any;
-        return response.Attributes as TResult;
-    }
+    const response = (await this.client.send(command)) as any;
+    return response.Attributes as TResult;
+  }
 }

package/src/builders/insert.ts

@@ -1,5 +1,5 @@
 import { PutCommand } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@repo/shared";
 import { Entity, type InferInsertModel } from "../core/table";
 import { BaseBuilder } from "./base";
 import { Column } from "../core/column";
@@ -9,176 +9,184 @@ import { calculateItemSize } from "../core/validation";
 import { ItemSizeExceededError } from "../core/errors";
 
 export class InsertBuilder<TEntity extends Entity> {
-    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "InsertBuilder";
-
-    constructor(
-        private entity: TEntity,
-        private client: IMizzleClient,
-    ) { }
-
-    /**
-     * Sets the values to be inserted into the database.
-     * 
-     * @example
-     * ```ts
-     * await db.insert(users).values({ id: "1", name: "Alice" }).execute();
-     * ```
-     * 
-     * @param values The object containing the attributes to insert.
-     * @returns An InsertBase instance for further chaining.
-     */
-    values(values: InferInsertModel<TEntity>): InsertBase<TEntity> {
-        return new InsertBase(this.entity, this.client, values);
-    }
+  static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "InsertBuilder";
+
+  constructor(
+    private entity: TEntity,
+    private client: IMizzleClient,
+  ) {}
+
+  /**
+   * Sets the values to be inserted into the database.
+   *
+   * @example
+   * ```ts
+   * await db.insert(users).values({ id: "1", name: "Alice" }).execute();
+   * ```
+   *
+   * @param values The object containing the attributes to insert.
+   * @returns An InsertBase instance for further chaining.
+   */
+  values(values: InferInsertModel<TEntity>): InsertBase<TEntity> {
+    return new InsertBase(this.entity, this.client, values);
+  }
 }
 
 interface MinimalPhysicalTable {
-    [TABLE_SYMBOLS.INDEXES]?: Record<string, { config: { pk: string; sk?: string } }>;
+  [TABLE_SYMBOLS.INDEXES]?: Record<string, { config: { pk: string; sk?: string } }>;
 }
 
-export class InsertBase<
-    TEntity extends Entity,
-    TResult = undefined,
-> extends BaseBuilder<TEntity, TResult> {
-    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "InsertBase";
-
-    private shouldReturnValues = false;
-
-    constructor(
-        entity: TEntity,
-        client: IMizzleClient,
-        private valuesData: InferInsertModel<TEntity>,
-    ) {
-        super(entity, client);
+export class InsertBase<TEntity extends Entity, TResult = undefined> extends BaseBuilder<
+  TEntity,
+  TResult
+> {
+  static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "InsertBase";
+
+  private shouldReturnValues = false;
+
+  constructor(
+    entity: TEntity,
+    client: IMizzleClient,
+    private valuesData: InferInsertModel<TEntity>,
+  ) {
+    super(entity, client);
+  }
+
+  /** @internal */
+  get values() {
+    return this.valuesData;
+  }
+
+  /**
+   * Instructs Mizzle to return the inserted item after execution.
+   *
+   * @returns The current builder instance with an updated result type.
+   */
+  returning(): InsertBase<TEntity, InferInsertModel<TEntity>> {
+    this.shouldReturnValues = true;
+    return this as unknown as InsertBase<TEntity, InferInsertModel<TEntity>>;
+  }
+
+  /** @internal */
+  buildItem(): Record<string, unknown> {
+    const itemToSave = this.processValues(this.valuesData);
+    const resolution = this.resolveKeys(undefined, itemToSave);
+
+    const finalItem: Record<string, unknown> = { ...itemToSave, ...resolution.keys };
+
+    // Also resolve GSI keys if they are defined in strategies but not in resolution.keys
+    const strategies = this.entity[ENTITY_SYMBOLS.ENTITY_STRATEGY] as unknown as Record<
+      string,
+      { pk: KeyStrategy; sk?: KeyStrategy }
+    >;
+    const physicalTable = this.entity[
+      ENTITY_SYMBOLS.PHYSICAL_TABLE
+    ] as unknown as MinimalPhysicalTable;
+    const indexes = physicalTable?.[TABLE_SYMBOLS.INDEXES] || {};
+
+    for (const [indexName, strategy] of Object.entries(strategies)) {
+      if (indexName === "pk" || indexName === "sk") continue;
+
+      const indexBuilder = indexes[indexName];
+      if (indexBuilder) {
+        if (strategy.pk && indexBuilder.config.pk) {
+          const pkValue = this.resolveStrategyValue(strategy.pk, itemToSave);
+          if (pkValue) finalItem[indexBuilder.config.pk] = pkValue;
+        }
+        if (strategy.sk && indexBuilder.config.sk) {
+          const skValue = this.resolveStrategyValue(strategy.sk, itemToSave);
+          if (skValue) finalItem[indexBuilder.config.sk] = skValue;
+        }
+      }
     }
 
-    /** @internal */
-    get values() {
-        return this.valuesData;
+    return finalItem;
+  }
+
+  /**
+   * Executes the insert operation.
+   *
+   * @returns A promise that resolves to the inserted item if `.returning()` was called, otherwise undefined.
+   * @throws {ItemSizeExceededError} if the item exceeds 400KB.
+   */
+  override async execute(): Promise<TResult> {
+    const finalItem = this.buildItem();
+
+    // Size validation
+    const size = calculateItemSize(finalItem);
+    if (size > 400 * 1024) {
+      throw new ItemSizeExceededError(
+        `Item size of ${Math.round(size / 1024)}KB exceeds the 400KB limit.`,
+      );
     }
 
-    /**
-     * Instructs Mizzle to return the inserted item after execution.
-     * 
-     * @returns The current builder instance with an updated result type.
-     */
-    returning(): InsertBase<TEntity, InferInsertModel<TEntity>> {
-        this.shouldReturnValues = true;
-        return this as unknown as InsertBase<TEntity, InferInsertModel<TEntity>>;
-    }
+    const command = new PutCommand({
+      TableName: this.tableName,
+      Item: finalItem,
+    });
 
-    /** @internal */
-    buildItem(): Record<string, unknown> {
-        const itemToSave = this.processValues(this.valuesData);
-        const resolution = this.resolveKeys(undefined, itemToSave);
-
-        const finalItem: Record<string, unknown> = { ...itemToSave, ...resolution.keys };
-
-        // Also resolve GSI keys if they are defined in strategies but not in resolution.keys
-        const strategies = this.entity[ENTITY_SYMBOLS.ENTITY_STRATEGY] as unknown as Record<string, { pk: KeyStrategy, sk?: KeyStrategy }>;
-        const physicalTable = this.entity[ENTITY_SYMBOLS.PHYSICAL_TABLE] as unknown as MinimalPhysicalTable;
-        const indexes = physicalTable?.[TABLE_SYMBOLS.INDEXES] || {};
-
-        for (const [indexName, strategy] of Object.entries(strategies)) {
-            if (indexName === "pk" || indexName === "sk") continue;
-
-            const indexBuilder = indexes[indexName];
-            if (indexBuilder) {
-                if (strategy.pk && indexBuilder.config.pk) {
-                    const pkValue = this.resolveStrategyValue(strategy.pk, itemToSave);
-                    if (pkValue) finalItem[indexBuilder.config.pk] = pkValue;
-                }
-                if (strategy.sk && indexBuilder.config.sk) {
-                    const skValue = this.resolveStrategyValue(strategy.sk, itemToSave);
-                    if (skValue) finalItem[indexBuilder.config.sk] = skValue;
-                }
-            }
-        }
+    await this.client.send(command);
+    if (this.shouldReturnValues) return finalItem as unknown as TResult;
 
-        return finalItem;
+    return undefined as unknown as TResult;
+  }
+
+  private resolveStrategyValue(
+    strategy: KeyStrategy,
+    availableValues: Record<string, unknown>,
+  ): string | undefined {
+    if (strategy.type === "static") {
+      return strategy.segments[0] as string;
     }
 
-    /**
-     * Executes the insert operation.
-     * 
-     * @returns A promise that resolves to the inserted item if `.returning()` was called, otherwise undefined.
-     * @throws {ItemSizeExceededError} if the item exceeds 400KB.
-     */
-    override async execute(): Promise<TResult> {
-        const finalItem = this.buildItem();
-
-        // Size validation
-        const size = calculateItemSize(finalItem);
-        if (size > 400 * 1024) {
-            throw new ItemSizeExceededError(`Item size of ${Math.round(size / 1024)}KB exceeds the 400KB limit.`);
-        }
+    const resolvedParts: string[] = [];
 
-        const command = new PutCommand({
-            TableName: this.tableName,
-            Item: finalItem,
-        });
+    for (const segment of strategy.segments) {
+      if (typeof segment === "string") {
+        resolvedParts.push(segment);
+      } else {
+        const val = availableValues[segment.name];
+        if (val === undefined || val === null) return undefined;
+        resolvedParts.push(String(val));
+      }
+    }
 
-        await this.client.send(command);
-        if (this.shouldReturnValues) return finalItem as unknown as TResult;
+    if (strategy.type === "prefix") return resolvedParts.join("");
+    if (strategy.type === "composite") return resolvedParts.join(strategy.separator || "#");
+    return undefined;
+  }
 
-        return undefined as unknown as TResult;
-    }
+  private processValues(values: InferInsertModel<TEntity>): Record<string, unknown> {
+    const item: Record<string, unknown> = { ...(values as Record<string, unknown>) };
+    const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, Column>;
 
-    private resolveStrategyValue(strategy: KeyStrategy, availableValues: Record<string, unknown>): string | undefined {
-        if (strategy.type === "static") {
-            return strategy.segments[0] as string;
-        }
+    for (const key in columns) {
+      const col = columns[key];
+      if (!col) continue;
 
-        const resolvedParts: string[] = [];
+      const value = item[key];
 
-        for (const segment of strategy.segments) {
-            if (typeof segment === "string") {
-                resolvedParts.push(segment);
-            } else {
-                const val = availableValues[segment.name];
-                if (val === undefined || val === null) return undefined;
-                resolvedParts.push(String(val));
-            }
-        }
+      if (value === undefined) {
+        if (col.default !== undefined) item[key] = col.default;
+        else if (col.defaultFn) item[key] = col.defaultFn();
+      }
 
-        if (strategy.type === "prefix") return resolvedParts.join("");
-        if (strategy.type === "composite") return resolvedParts.join(strategy.separator || "#");
-        return undefined;
-    }
+      const finalValue = item[key];
 
-    private processValues(
-        values: InferInsertModel<TEntity>,
-    ): Record<string, unknown> {
-        const item: Record<string, unknown> = { ...(values as Record<string, unknown>) };
-        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, Column>;
-
-        for (const key in columns) {
-            const col = columns[key];
-            if (!col) continue;
-
-            const value = item[key];
-
-            if (value === undefined) {
-                if (col.default !== undefined) item[key] = col.default;
-                else if (col.defaultFn) item[key] = col.defaultFn();
-            }
-
-            const finalValue = item[key];
-
-            // Check if column has mapToDynamoValue method (it's on the Column class)
-            if (col instanceof Column) {
-                item[key] = col.mapToDynamoValue(finalValue);
-            }
-
-            if (["SS", "NS", "BS"].includes(col.columnType)) {
-                if (Array.isArray(finalValue)) {
-                    const setVal = new Set(finalValue);
-                    item[key] = setVal;
-                    if (setVal.size === 0) delete item[key];
-                }
-            }
-        }
+      // Check if column has mapToDynamoValue method (it's on the Column class)
+      if (col instanceof Column) {
+        item[key] = col.mapToDynamoValue(finalValue);
+      }
 
-        return item;
+      if (["SS", "NS", "BS"].includes(col.columnType)) {
+        if (Array.isArray(finalValue)) {
+          const setVal = new Set(finalValue);
+          item[key] = setVal;
+          if (setVal.size === 0) delete item[key];
+        }
+      }
     }
+
+    return item;
+  }
 }

package/src/builders/query-promise.ts

@@ -1,41 +1,32 @@
 export abstract class QueryPromise<T> implements Promise<T> {
-    [Symbol.toStringTag] = "QueryPromise";
+  [Symbol.toStringTag] = "QueryPromise";
 
-    catch<TResult = never>(
-        onrejected?:
-            | ((reason: unknown) => TResult | PromiseLike<TResult>)
-            | null
-            | undefined,
-    ): Promise<T | TResult> {
-        return this.then(undefined, onrejected);
-    }
+  catch<TResult = never>(
+    onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null | undefined,
+  ): Promise<T | TResult> {
+    return this.then(undefined, onrejected);
+  }
 
-    finally(onfinally?: (() => void) | null | undefined): Promise<T> {
-        return this.then(
-            (value) => {
-                onfinally?.();
-                return value;
-            },
-            (reason) => {
-                onfinally?.();
-                throw reason;
-            },
-        );
-    }
+  finally(onfinally?: (() => void) | null | undefined): Promise<T> {
+    return this.then(
+      (value) => {
+        onfinally?.();
+        return value;
+      },
+      (reason) => {
+        onfinally?.();
+        throw reason;
+      },
+    );
+  }
 
-    // oxlint-disable
-    then<TResult1 = T, TResult2 = never>(
-        onfulfilled?:
-            | ((value: T) => TResult1 | PromiseLike<TResult1>)
-            | null
-            | undefined,
-        onrejected?:
-            | ((reason: unknown) => TResult2 | PromiseLike<TResult2>)
-            | null
-            | undefined,
-    ): Promise<TResult1 | TResult2> {
-        return this.execute().then(onfulfilled, onrejected);
-    }
+  // oxlint-disable
+  then<TResult1 = T, TResult2 = never>(
+    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined,
+    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null | undefined,
+  ): Promise<TResult1 | TResult2> {
+    return this.execute().then(onfulfilled, onrejected);
+  }
 
-    abstract execute(): Promise<T>;
+  abstract execute(): Promise<T>;
 }