@aurios/mizzle 1.0.0

package/src/builders/update.ts

@@ -0,0 +1,155 @@
+import { UpdateCommand } from "@aws-sdk/lib-dynamodb";
+import { ENTITY_SYMBOLS } from "@mizzle/shared";
+import { Entity, type InferInsertModel } from "../core/table";
+import { type Expression } from "../expressions/operators";
+import { BaseBuilder } from "./base";
+import { type IMizzleClient } from "../core/client";
+import { calculateItemSize } from "../core/validation";
+import { ItemSizeExceededError } from "../core/errors";
+import { buildExpression } from "../expressions/builder";
+import { UpdateAction } from "../expressions/actions";
+import { 
+    createUpdateState, 
+    partitionUpdateValues, 
+    buildUpdateExpressionString 
+} from "../expressions/update-builder";
+
+export class UpdateBuilder<
+    TEntity extends Entity,
+    TResult = unknown,
+> extends BaseBuilder<TEntity, TResult> {
+    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "UpdateBuilder";
+
+    private _state = createUpdateState();
+    private _whereClause?: Expression;
+    private _returnValues?: "NONE" | "ALL_OLD" | "UPDATED_OLD" | "ALL_NEW" | "UPDATED_NEW";
+    private _explicitKey?: Record<string, unknown>;
+
+    constructor(
+        entity: TEntity,
+        client: IMizzleClient,
+    ) {
+        super(entity, client);
+    }
+
+    key(keyObject: Record<string, unknown>): this {
+        this._explicitKey = keyObject;
+        return this;
+    }
+
+    set(values: Partial<{ [K in keyof InferInsertModel<TEntity>]: InferInsertModel<TEntity>[K] | UpdateAction }>): this {
+        partitionUpdateValues(values as Record<string, any>, this._state, this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>);
+        return this;
+    }
+
+    add(values: Partial<InferInsertModel<TEntity>>): this {
+        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
+        for (const [key, val] of Object.entries(values)) {
+            const col = columns[key];
+            this._state.add[key] = (col && typeof col.mapToDynamoValue === "function") 
+                ? col.mapToDynamoValue(val) 
+                : val;
+        }
+        return this;
+    }
+
+    remove(...fields: (keyof InferInsertModel<TEntity> | (string & {}))[]): this {
+        this._state.remove.push(...(fields as string[]));
+        return this;
+    }
+
+    delete(values: Partial<InferInsertModel<TEntity>>): this {
+        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
+        for (const [key, val] of Object.entries(values)) {
+            const col = columns[key];
+            this._state.delete[key] = (col && typeof col.mapToDynamoValue === "function") 
+                ? col.mapToDynamoValue(val) 
+                : val;
+        }
+        return this;
+    }
+
+    where(expression: Expression): this {
+        this._whereClause = expression;
+        return this;
+    }
+
+    returning(value: "NONE" | "ALL_OLD" | "UPDATED_OLD" | "ALL_NEW" | "UPDATED_NEW"): this {
+        this._returnValues = value;
+        return this;
+    }
+
+    /** @internal */
+    get state() {
+        return this._state;
+    }
+
+    /** @internal */
+    get whereClause() {
+        return this._whereClause;
+    }
+
+    /** @internal */
+    public override createExpressionContext(prefix = "") {
+        return super.createExpressionContext(prefix);
+    }
+
+    public override async execute(): Promise<TResult> {
+        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
+        for (const [key, col] of Object.entries(columns)) {
+            if (col.onUpdateFn && !this._state.set[key] && !this._state.remove.includes(key)) {
+                const val = col.onUpdateFn();
+                this._state.set[key] = { 
+                    value: typeof col.mapToDynamoValue === "function" ? col.mapToDynamoValue(val) : val 
+                };
+            }
+        }
+
+        const keys = this.resolveUpdateKeys();
+
+        const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = this.createExpressionContext("up_");
+
+        const updateExpression = buildUpdateExpressionString(this._state, addName, addValue);
+        
+        let conditionExpression: string | undefined;
+        if (this._whereClause) {
+            conditionExpression = buildExpression(this._whereClause, addName, addValue);
+        }
+
+        // Estimate size for Update
+        // Update size is basically keys + attribute values.
+        const size = calculateItemSize({ ...keys, ...expressionAttributeValues });
+        if (size > 400 * 1024) {
+            throw new ItemSizeExceededError(`Estimated update size of ${Math.round(size / 1024)}KB exceeds the 400KB limit.`);
+        }
+
+        const command = new UpdateCommand({
+            TableName: this.tableName,
+            Key: keys,
+            UpdateExpression: updateExpression,
+            ConditionExpression: conditionExpression,
+            ExpressionAttributeNames:
+                Object.keys(expressionAttributeNames).length > 0
+                    ? expressionAttributeNames
+                    : undefined,
+            ExpressionAttributeValues:
+                Object.keys(expressionAttributeValues).length > 0
+                    ? expressionAttributeValues
+                    : undefined,
+            ReturnValues: this._returnValues,
+        });
+
+        const response = await this.client.send(command);
+        return response.Attributes as TResult;
+    }
+
+    /** @internal */
+    public resolveUpdateKeys(): Record<string, unknown> {
+        if (this._explicitKey) {
+            return this._explicitKey;
+        }
+
+        const resolved = this.resolveKeys(this._whereClause);
+        return resolved.keys;
+    }
+}

package/src/columns/binary-set.ts

@@ -0,0 +1,49 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type BinarySetColumnInitial<TName extends string> =
+    BinarySetColumnBuilder<{
+        name: TName;
+        dataType: "binarySet";
+        columnType: "BS";
+        data: Set<Uint8Array>;
+    }>;
+
+export class BinarySetColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"binarySet", "BS">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "binarySet", "BS");
+    }
+
+    override build<TTableName extends string>(
+        table: AnyTable,
+    ): BinarySetColumn<MakeColumnConfig<T, TTableName>> {
+        return new BinarySetColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class BinarySetColumn<
+    T extends ColumnBaseConfig<"binarySet", "BS">,
+> extends Column<T> {
+}
+
+export function binarySet(): BinarySetColumnInitial<"">;
+export function binarySet<TName extends string>(
+    name: TName,
+): BinarySetColumnInitial<TName>;
+export function binarySet(name?: string) {
+    return new BinarySetColumnBuilder(name ?? "");
+}

package/src/columns/binary.ts

@@ -0,0 +1,48 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type BinaryBuilderInitial<TName extends string> = BinaryColumnBuilder<{
+    name: TName;
+    dataType: "binary";
+    columnType: "B";
+    data: Buffer;
+}>;
+
+export class BinaryColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"binary", "B">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "binary", "B");
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): BinaryColumn<MakeColumnConfig<T, TTableName>> {
+        return new BinaryColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class BinaryColumn<
+    T extends ColumnBaseConfig<"binary", "B">,
+> extends Column<T> {
+}
+
+export function binary(): BinaryBuilderInitial<"">;
+export function binary<TName extends string>(
+    name: TName,
+): BinaryBuilderInitial<TName>;
+export function binary(name?: string) {
+    return new BinaryColumnBuilder(name ?? "");
+}

package/src/columns/boolean.ts

@@ -0,0 +1,45 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type ColumnBuilderRuntimeConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type BooleanColumnInitial<TName extends string> = BooleanColumnBuilder<{
+    name: TName;
+    dataType: "boolean";
+    columnType: "BOOL";
+    data: boolean;
+}>;
+
+export class BooleanColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"boolean", "BOOL">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "boolean", "BOOL");
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): BooleanColumn<MakeColumnConfig<T, TTableName>> {
+        return new BooleanColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class BooleanColumn<
+    T extends ColumnBaseConfig<"boolean", "BOOL">,
+> extends Column<T> {
+}
+
+export function boolean(): BooleanColumnInitial<"">;
+export function boolean<TName extends string>(
+    name: TName,
+): BooleanColumnInitial<TName>;
+export function boolean(name?: string) {
+    return new BooleanColumnBuilder(name ?? "");
+}

package/src/columns/date.ts

@@ -0,0 +1,83 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+    type HasDefault,
+    type HasRuntimeDefault,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type DateColumnInitial<TName extends string> = DateColumnBuilder<{
+    name: TName;
+    dataType: "date";
+    columnType: "S";
+    data: Date;
+}>;
+
+export class DateColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"date", "S">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "date", "S");
+    }
+
+    defaultNow(): HasRuntimeDefault<HasDefault<this>> {
+        return this.$defaultFn(() => new Date() as any);
+    }
+
+    onUpdateNow(): HasDefault<this> {
+        return this.$onUpdateFn(() => new Date() as any);
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): DateColumn<MakeColumnConfig<T, TTableName>> {
+        return new DateColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class DateColumn<
+    T extends ColumnBaseConfig<"date", "S">,
+> extends Column<T> {
+    override mapToDynamoValue(value: unknown): unknown {
+        if (value === null || value === undefined) {
+            return value;
+        }
+
+        let date: Date;
+        if (value instanceof Date) {
+            date = value;
+        } else if (typeof value === "string" || typeof value === "number") {
+            date = new Date(value);
+        } else {
+            throw new Error(`Invalid date value: ${value}`);
+        }
+
+        if (Number.isNaN(date.getTime())) {
+            throw new Error(`Invalid date value: ${value}`);
+        }
+
+        return date.toISOString();
+    }
+
+    override mapFromDynamoValue(value: unknown): unknown {
+        if (typeof value === "string") {
+            return new Date(value);
+        }
+        return value;
+    }
+}
+
+export function date(): DateColumnInitial<"">;
+export function date<TName extends string>(name: TName): DateColumnInitial<TName>;
+export function date(name?: string) {
+    return new DateColumnBuilder(name ?? "");
+}

package/src/columns/index.ts

@@ -0,0 +1,44 @@
+export { binary } from "./binary";
+export { binarySet } from "./binary-set";
+export { boolean } from "./boolean";
+export { date } from "./date";
+export { list } from "./list";
+export { map } from "./map";
+export { number } from "./number";
+export { numberSet } from "./number-set";
+export { string } from "./string";
+export { stringSet } from "./string-set";
+export { uuid } from "./uuid";
+export { json } from "./json";
+
+import { binary } from "./binary";
+import { binarySet } from "./binary-set";
+import { boolean } from "./boolean";
+import { date } from "./date";
+import { json } from "./json";
+import { list } from "./list";
+import { map } from "./map";
+import { number } from "./number";
+import { numberSet } from "./number-set";
+import { string } from "./string";
+import { stringSet } from "./string-set";
+import { uuid } from "./uuid";
+
+export function getColumnBuilders() {
+    return {
+        binary,
+        binarySet,
+        boolean,
+        date,
+        json,
+        list,
+        map,
+        number,
+        numberSet,
+        string,
+        stringSet,
+        uuid,
+    };
+}
+
+export type ColumnsBuilder = ReturnType<typeof getColumnBuilders>;

package/src/columns/json.ts

@@ -0,0 +1,62 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type JsonColumnInitial<TName extends string> = JsonColumnBuilder<{
+    name: TName;
+    dataType: "json";
+    columnType: "S";
+    data: unknown;
+}>;
+
+export class JsonColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"json", "S">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "json", "S");
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): JsonColumn<MakeColumnConfig<T, TTableName>> {
+        return new JsonColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class JsonColumn<
+    T extends ColumnBaseConfig<"json", "S">,
+> extends Column<T> {
+    override mapToDynamoValue(value: T["data"]): string {
+        return JSON.stringify(value);
+    }
+
+    override mapFromDynamoValue(value: T["data"] | string): T["data"] {
+        if (typeof value === "string") {
+            try {
+                return JSON.parse(value);
+            } catch {
+                return value as T["data"];
+            }
+        }
+        return value;
+    }
+}
+
+export function json(): JsonColumnInitial<"">;
+export function json<TName extends string>(
+    name: TName,
+): JsonColumnInitial<TName>;
+export function json(name?: string) {
+    return new JsonColumnBuilder(name ?? "");
+}

package/src/columns/list.ts

@@ -0,0 +1,47 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type ListColumnInitial<TName extends string> = ListColumnBuilder<{
+    name: TName;
+    data: unknown[];
+    dataType: "array";
+    columnType: "L";
+}>;
+
+export class ListColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"array", "L">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "array", "L");
+    }
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): ListColumn<MakeColumnConfig<T, TTableName>> {
+        return new ListColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class ListColumn<
+    T extends ColumnBaseConfig<"array", "L">,
+> extends Column<T> {
+}
+
+export function list(): ListColumnInitial<"">;
+export function list<TName extends string>(
+    name: TName,
+): ListColumnInitial<TName>;
+export function list(name?: string) {
+    return new ListColumnBuilder(name ?? "");
+}

package/src/columns/map.ts

@@ -0,0 +1,46 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type MapColumnInitial<TName extends string> = MapColumnBuilder<{
+    name: TName;
+    data: Record<string, unknown>;
+    dataType: "map";
+    columnType: "M";
+}>;
+
+export class MapColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"map", "M">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "map", "M");
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): MapColumn<MakeColumnConfig<T, TTableName>> {
+        return new MapColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class MapColumn<
+    T extends ColumnBaseConfig<"map", "M">,
+> extends Column<T> {
+}
+
+export function map(): MapColumnInitial<"">;
+export function map<TName extends string>(name: TName): MapColumnInitial<TName>;
+export function map(name?: string) {
+    return new MapColumnBuilder(name ?? "");
+}

package/src/columns/number-set.ts

@@ -0,0 +1,49 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type NumberSetColumnInitial<TName extends string> =
+    NumberSetColumnBuilder<{
+        name: TName;
+        data: Set<number>;
+        columnType: "NS";
+        dataType: "numberSet";
+    }>;
+
+export class NumberSetColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"numberSet", "NS">,
+> extends ColumnBuider<T> {
+    constructor(name: T["name"]) {
+        super(name, "numberSet", "NS");
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): NumberSetColumn<MakeColumnConfig<T, TTableName>> {
+        return new NumberSetColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class NumberSetColumn<
+    T extends ColumnBaseConfig<"numberSet", "NS">,
+> extends Column<T> {
+}
+
+export function numberSet(): NumberSetColumnInitial<"">;
+export function numberSet<TName extends string>(
+    name: TName,
+): NumberSetColumnInitial<TName>;
+export function numberSet(name?: string) {
+    return new NumberSetColumnBuilder(name ?? "");
+}

package/src/columns/number.ts

@@ -0,0 +1,57 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
+import {
+    ColumnBuider,
+    type MakeColumnConfig,
+    type ColumnBuilderBaseConfig,
+    type ColumnBuilderRuntimeConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type NumberColumnInitial<TName extends string> = NumberColumnBuilder<{
+    name: TName;
+    dataType: "number";
+    columnType: "N";
+    data: number;
+}>;
+
+export class NumberColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"number", "N">,
+> extends ColumnBuider<T, { validators?: { min?: number; max?: number } }> {
+    constructor(name: T["name"]) {
+        super(name, "number", "N");
+    }
+
+    min(value: number): this {
+        this.config.validators ??= {};
+        this.config.validators.min = value;
+        return this;
+    }
+
+    max(value: number): this {
+        this.config.validators ??= {};
+        this.config.validators.max = value;
+        return this;
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): NumberColumn<MakeColumnConfig<T, TTableName>> {
+        return new NumberColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class NumberColumn<
+    T extends ColumnBaseConfig<"number", "N">,
+> extends Column<T> {
+}
+
+export function number(): NumberColumnInitial<"">;
+export function number<TName extends string>(
+    name: TName,
+): NumberColumnInitial<TName>;
+export function number(name?: string) {
+    return new NumberColumnBuilder(name ?? "");
+}