@aurios/mizzle 1.1.2 → 1.1.4

package/src/columns/boolean.ts

@@ -1,58 +1,53 @@
 import { Column, type ColumnBaseConfig } from "../core/column";
 import {
-    ColumnBuider,
-    type ColumnBuilderBaseConfig,
-    type MakeColumnConfig,
+  ColumnBuider,
+  type ColumnBuilderBaseConfig,
+  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;
+  name: TName;
+  dataType: "boolean";
+  columnType: "BOOL";
+  data: boolean;
 }>;
 
 export class BooleanColumnBuilder<
-    T extends ColumnBuilderBaseConfig<"boolean", "BOOL">,
+  T extends ColumnBuilderBaseConfig<"boolean", "BOOL">,
 > extends ColumnBuider<T> {
-    constructor(name: T["name"]) {
-        super(name, "boolean", "BOOL");
-    }
+  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,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.config as any,
-        );
-    }
+  build<TTableName extends string>(
+    table: AnyTable,
+  ): BooleanColumn<MakeColumnConfig<T, TTableName>> {
+    return new BooleanColumn<MakeColumnConfig<T, TTableName>>(
+      table,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.config as any,
+    );
+  }
 }
 
-export class BooleanColumn<
-    T extends ColumnBaseConfig<"boolean", "BOOL">,
-> extends Column<T> {
-}
+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<TName extends string>(name: TName): BooleanColumnInitial<TName>;
 /**
  * Defines a Boolean column ("BOOL") in DynamoDB.
- * 
+ *
  * @example
  * ```ts
  * const users = defineTable("users", {
  *   isActive: boolean("is_active").default(true),
  * });
  * ```
- * 
+ *
  * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
  * @returns A BooleanColumnBuilder instance.
  */
 export function boolean(name?: string) {
-    return new BooleanColumnBuilder(name ?? "");
+  return new BooleanColumnBuilder(name ?? "");
 }

package/src/columns/date.ts

@@ -1,91 +1,84 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
 import {
-    Column,
-    type ColumnBaseConfig,
-} from "../core/column";
-import {
-    ColumnBuider,
-    type ColumnBuilderBaseConfig,
-    type MakeColumnConfig,
-    type HasDefault,
-    type HasRuntimeDefault,
+  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;
+  name: TName;
+  dataType: "date";
+  columnType: "S";
+  data: Date;
 }>;
 
 export class DateColumnBuilder<
-    T extends ColumnBuilderBaseConfig<"date", "S">,
+  T extends ColumnBuilderBaseConfig<"date", "S">,
 > extends ColumnBuider<T> {
-    constructor(name: T["name"]) {
-        super(name, "date", "S");
-    }
+  constructor(name: T["name"]) {
+    super(name, "date", "S");
+  }
 
-    defaultNow(): HasRuntimeDefault<HasDefault<this>> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return this.$defaultFn(() => new Date() as any);
-    }
+  defaultNow(): HasRuntimeDefault<HasDefault<this>> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this.$defaultFn(() => new Date() as any);
+  }
 
-    onUpdateNow(): HasDefault<this> {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return this.$onUpdateFn(() => new Date() as any);
-    }
+  onUpdateNow(): HasDefault<this> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this.$onUpdateFn(() => new Date() as any);
+  }
 
-    build<TTableName extends string>(
-        table: AnyTable,
-    ): DateColumn<MakeColumnConfig<T, TTableName>> {
-        return new DateColumn<MakeColumnConfig<T, TTableName>>(
-            table,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.config as any,
-        );
-    }
+  build<TTableName extends string>(table: AnyTable): DateColumn<MakeColumnConfig<T, TTableName>> {
+    return new DateColumn<MakeColumnConfig<T, TTableName>>(
+      table,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      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}`);
-        }
+export class DateColumn<T extends ColumnBaseConfig<"date", "S">> extends Column<T> {
+  override mapToDynamoValue(value: unknown): unknown {
+    if (value === null || value === undefined) {
+      return value;
+    }
 
-        if (Number.isNaN(date.getTime())) {
-            throw new Error(`Invalid date value: ${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}`);
+    }
 
-        return date.toISOString();
+    if (Number.isNaN(date.getTime())) {
+      throw new Error(`Invalid date value: ${value}`);
     }
 
-    override mapFromDynamoValue(value: unknown): unknown {
-        if (typeof value === "string") {
-            return new Date(value);
-        }
-        return 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>;
 /**
  * Defines a Date column.
- * 
- * In DynamoDB, this is stored as an ISO 8601 string ("S"), but Mizzle automatically 
+ *
+ * In DynamoDB, this is stored as an ISO 8601 string ("S"), but Mizzle automatically
  * handles conversion to/from JavaScript Date objects in your application code.
- * 
+ *
  * @example
  * ```ts
  * const posts = defineTable("posts", {
@@ -93,10 +86,10 @@ export function date<TName extends string>(name: TName): DateColumnInitial<TName
  *   updatedAt: date("updated_at").onUpdateNow(),
  * });
  * ```
- * 
+ *
  * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
  * @returns A DateColumnBuilder instance.
  */
 export function date(name?: string) {
-    return new DateColumnBuilder(name ?? "");
+  return new DateColumnBuilder(name ?? "");
 }

package/src/columns/index.ts

@@ -25,20 +25,20 @@ 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,
-    };
+  return {
+    binary,
+    binarySet,
+    boolean,
+    date,
+    json,
+    list,
+    map,
+    number,
+    numberSet,
+    string,
+    stringSet,
+    uuid,
+  };
 }
 
-export type ColumnsBuilder = ReturnType<typeof getColumnBuilders>;
+export type ColumnsBuilder = ReturnType<typeof getColumnBuilders>;

package/src/columns/json.ts

@@ -1,85 +1,76 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
 import {
-    Column,
-    type ColumnBaseConfig,
-} from "../core/column";
-import {
-    ColumnBuider,
-    type ColumnBuilderBaseConfig,
-    type MakeColumnConfig,
+  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;
+  name: TName;
+  dataType: "json";
+  columnType: "S";
+  data: unknown;
 }>;
 
 export class JsonColumnBuilder<
-    T extends ColumnBuilderBaseConfig<"json", "S">,
+  T extends ColumnBuilderBaseConfig<"json", "S">,
 > extends ColumnBuider<T> {
-    constructor(name: T["name"]) {
-        super(name, "json", "S");
-    }
+  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,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.config as any,
-        );
-    }
+  build<TTableName extends string>(table: AnyTable): JsonColumn<MakeColumnConfig<T, TTableName>> {
+    return new JsonColumn<MakeColumnConfig<T, TTableName>>(
+      table,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      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);
-    }
+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;
+  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<TName extends string>(name: TName): JsonColumnInitial<TName>;
 /**
  * Defines a JSON column.
- * 
+ *
  * In DynamoDB, this is stored as a string ("S") containing serialized JSON.
  * Mizzle automatically handles JSON.stringify/parse for you.
- * 
+ *
  * You can type the JSON object using the `.$type<T>()` method.
- * 
+ *
  * @example
  * ```ts
  * interface Address {
  *   street: string;
  *   city: string;
  * }
- * 
+ *
  * const users = defineTable("users", {
  *   address: json("address").$type<Address>(),
  * });
  * ```
- * 
+ *
  * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
  * @returns A JsonColumnBuilder instance.
  */
 export function json(name?: string) {
-    return new JsonColumnBuilder(name ?? "");
+  return new JsonColumnBuilder(name ?? "");
 }

package/src/columns/list.ts

@@ -1,63 +1,53 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
 import {
-    Column,
-    type ColumnBaseConfig,
-} from "../core/column";
-import {
-    ColumnBuider,
-    type ColumnBuilderBaseConfig,
-    type MakeColumnConfig,
+  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";
+  name: TName;
+  data: unknown[];
+  dataType: "array";
+  columnType: "L";
 }>;
 
 export class ListColumnBuilder<
-    T extends ColumnBuilderBaseConfig<"array", "L">,
+  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,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.config as any,
-        );
-    }
+  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,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.config as any,
+    );
+  }
 }
 
-export class ListColumn<
-    T extends ColumnBaseConfig<"array", "L">,
-> extends Column<T> {
-}
+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<TName extends string>(name: TName): ListColumnInitial<TName>;
 /**
  * Defines a List column ("L") in DynamoDB.
- * 
- * A list is an ordered collection of values. It can store mixed types, 
+ *
+ * A list is an ordered collection of values. It can store mixed types,
  * but you can enforce a specific type using `.$type<T[]>()`.
- * 
+ *
  * @example
  * ```ts
  * const posts = defineTable("posts", {
  *   tags: list("tags").$type<string[]>(),
  * });
  * ```
- * 
+ *
  * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
  * @returns A ListColumnBuilder instance.
  */
 export function list(name?: string) {
-    return new ListColumnBuilder(name ?? "");
+  return new ListColumnBuilder(name ?? "");
 }

package/src/columns/map.ts

@@ -1,63 +1,55 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
 import {
-    Column,
-    type ColumnBaseConfig,
-} from "../core/column";
-import {
-    ColumnBuider,
-    type ColumnBuilderBaseConfig,
-    type MakeColumnConfig,
+  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";
+  name: TName;
+  data: Record<string, unknown>;
+  dataType: "map";
+  columnType: "M";
 }>;
 
 export class MapColumnBuilder<
-    T extends ColumnBuilderBaseConfig<"map", "M">,
+  T extends ColumnBuilderBaseConfig<"map", "M">,
 > extends ColumnBuider<T> {
-    constructor(name: T["name"]) {
-        super(name, "map", "M");
-    }
+  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,
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            this.config as any,
-        );
-    }
+  build<TTableName extends string>(table: AnyTable): MapColumn<MakeColumnConfig<T, TTableName>> {
+    return new MapColumn<MakeColumnConfig<T, TTableName>>(
+      table,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      this.config as any,
+    );
+  }
 }
 
-export class MapColumn<
-    T extends ColumnBaseConfig<"map", "M">,
-> extends Column<T> {
-}
+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>;
 /**
  * Defines a Map column ("M") in DynamoDB.
- * 
- * A map is a set of key-value pairs (like a JSON object). 
- * Unlike `json()`, this is stored as a native DynamoDB Map, allowing you to filter/query nested properties 
+ *
+ * A map is a set of key-value pairs (like a JSON object).
+ * Unlike `json()`, this is stored as a native DynamoDB Map, allowing you to filter/query nested properties
  * more easily in some contexts, though `json()` is often preferred for simple object storage.
- * 
+ *
  * @example
  * ```ts
  * const users = defineTable("users", {
  *   metadata: map("metadata").$type<{ verified: boolean, loginCount: number }>(),
  * });
  * ```
- * 
+ *
  * @param name The name of the attribute in DynamoDB. If omitted, it will use the property name in the definition object.
  * @returns A MapColumnBuilder instance.
  */
 export function map(name?: string) {
-    return new MapColumnBuilder(name ?? "");
+  return new MapColumnBuilder(name ?? "");
 }