@aurios/mizzle 1.0.0

package/src/columns/string-set.ts

@@ -0,0 +1,59 @@
+import {
+    Column,
+    type ColumnBaseConfig,
+    type ColumnRuntimeConfig,
+} from "../core/column";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type HasDefault,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+export type StringSetColumnInitial<TName extends string> =
+    StringSetColumnBuilder<{
+        name: TName;
+        dataType: "string";
+        columnType: "SS";
+        data: Set<string>;
+    }>;
+
+export class StringSetColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"string", "SS">,
+> extends ColumnBuider<T> {
+    constructor(name: string) {
+        super(name, "string", "SS");
+    }
+
+    override default(
+        value: this["_"] extends { $type: infer U } ? U : this["_"]["data"],
+    ): HasDefault<this> {
+        const setVal = value instanceof Set ? value : new Set(value as []);
+        this.config.default = setVal;
+        this.config.hasDefault = true;
+        return this as HasDefault<this>;
+    }
+
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): StringSetColumn<MakeColumnConfig<T, TTableName>> {
+        return new StringSetColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class StringSetColumn<
+    T extends ColumnBaseConfig<"string", "SS">,
+> extends Column<T> {
+}
+
+export function stringSet(): StringSetColumnInitial<"">;
+export function stringSet<TName extends string>(
+    name: TName,
+): StringSetColumnInitial<TName>;
+export function stringSet(name?: string) {
+    return new StringSetColumnBuilder(name ?? "");
+}

package/src/columns/string.ts

@@ -0,0 +1,64 @@
+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 StringColumnInitial<TName extends string> = StringColumnBuilder<{
+    name: TName;
+    dataType: "string";
+    columnType: "S";
+    data: string;
+}>;
+
+class StringColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"string", "S">,
+> extends ColumnBuider<
+    T,
+    { validators?: { length?: number; email?: boolean } }
+> {
+    constructor(name: string) {
+        super(name, "string", "S");
+    }
+
+    length(value: number): this {
+        this.config.validators ??= {};
+        this.config.validators.length = value;
+        return this;
+    }
+
+    email(): this {
+        this.config.validators ??= {};
+        this.config.validators.email = true;
+        return this;
+    }
+
+    /** @internal */
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): StringColumn<MakeColumnConfig<T, TTableName>> {
+        return new StringColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class StringColumn<
+    T extends ColumnBaseConfig<"string", "S">,
+> extends Column<T> {
+}
+
+export function string(): StringColumnInitial<"">;
+export function string<TName extends string>(
+    name: TName,
+): StringColumnInitial<TName>;
+export function string(name?: string) {
+    return new StringColumnBuilder(name ?? "");
+}

package/src/columns/uuid.ts

@@ -0,0 +1,51 @@
+import { Column, type ColumnBaseConfig } from "../core/column";
+import { v7 as uuidV7 } from "uuid";
+import {
+    ColumnBuider,
+    type ColumnBuilderBaseConfig,
+    type ColumnBuilderRuntimeConfig,
+    type MakeColumnConfig,
+} from "../core/column-builder";
+import type { AnyTable } from "../core/table";
+
+const uuidDefault = () => uuidV7();
+
+export type UUIDColumnInitial<TName extends string> = UUIDColumnBuilder<{
+    name: TName;
+    dataType: "string";
+    columnType: "S";
+    data: string;
+}>;
+
+export class UUIDColumnBuilder<
+    T extends ColumnBuilderBaseConfig<"string", "S">,
+> extends ColumnBuider<T> {
+    constructor(name: string) {
+        super(name, "string", "S");
+
+        this.config.defaultFn = uuidDefault;
+    }
+
+    /** @internal */
+    build<TTableName extends string>(
+        table: AnyTable,
+    ): UUIDColumn<MakeColumnConfig<T, TTableName>> {
+        return new UUIDColumn<MakeColumnConfig<T, TTableName>>(
+            table,
+            this.config as any,
+        );
+    }
+}
+
+export class UUIDColumn<
+    T extends ColumnBaseConfig<"string", "S">,
+> extends Column<T> {
+}
+
+export function uuid(): UUIDColumnInitial<"">;
+export function uuid<TName extends string>(
+    name: TName,
+): UUIDColumnInitial<TName>;
+export function uuid(name?: string) {
+    return new UUIDColumnBuilder(name ?? "");
+}

package/src/core/client.ts

@@ -0,0 +1,18 @@
+import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
+import { RetryHandler } from "./retry";
+
+// We define a simplified interface for what we need from the client to avoid complex generic matching
+export interface IMizzleClient {
+    send(command: any, options?: any): Promise<any>;
+}
+
+export class MizzleClient implements IMizzleClient {
+    constructor(
+        private client: DynamoDBDocumentClient,
+        private retryHandler: RetryHandler
+    ) {}
+
+    send(command: any, options?: any): Promise<any> {
+        return this.retryHandler.execute(() => this.client.send(command, options));
+    }
+}

package/src/core/column-builder.ts

@@ -0,0 +1,272 @@
+import { type Column, ExtraConfigColumn } from "./column";
+import type { AnyTable } from "./table";
+import type { Assume, Simplify } from "@mizzle/shared";
+
+export type ColumnDataType =
+    | "S"
+    | "N"
+    | "BOOL"
+    | "M"
+    | "L"
+    | "B"
+    | "BS"
+    | "NS"
+    | "NULL"
+    | "SS";
+
+export interface ColumnBuilderBaseConfig<
+    TDataType extends string,
+    TColumnDataType extends ColumnDataType,
+> {
+    name: string;
+    dataType: TDataType;
+    columnType: TColumnDataType;
+    data: unknown;
+}
+
+export type BuildExtraConfigColumns<
+    TConfigMap extends Record<string, ColumnBuilderBase>,
+> = Simplify<{ [Key in keyof TConfigMap]: ExtraConfigColumn }>;
+
+export type MakeColumnConfig<
+    T extends ColumnBuilderBaseConfig<string, ColumnDataType>,
+    TTableName extends string,
+    TData = T extends { $type: infer U } ? U : T["data"],
+> = {
+    name: T["name"];
+    tableName: TTableName;
+    dataType: T["dataType"];
+    columnType: T["columnType"];
+    data: TData;
+    notNull: T extends { notNull: true } ? true : false;
+    hasDefault: T extends { hasDefault: true } ? true : false;
+    hasRuntimeDefault: T extends { hasRuntimeDefault: true } ? true : false;
+    isPartitionKey: T extends { isPartitionKey: true } ? true : false;
+    isSortKey: T extends { isSortKey: true } ? true : false;
+} & object;
+
+export type ColumnBuilderRuntimeConfig<
+    TData,
+    TRuntimeConfig extends object = object,
+> = {
+    name: string;
+    notNull: boolean;
+    default: TData;
+    dataType: string;
+    columnType: string;
+    isPartitionKey: boolean;
+    isSortKey: boolean;
+    hasDefault: boolean;
+    partitionKey: boolean;
+    sortKey: boolean;
+    defaultFn: () => TData | undefined;
+    onUpdateFn: () => TData | undefined;
+} & TRuntimeConfig;
+
+export type ColumnBuilderTypeConfig<
+    T extends ColumnBuilderBaseConfig<string, ColumnDataType>,
+    TTypeConfig extends object = object,
+> = Simplify<
+    {
+        name: T["name"];
+        dataType: T["dataType"];
+        data: T["data"];
+        columnType: T["columnType"];
+        notNull: T extends { notNull: infer U } ? U : boolean;
+        hasDefault: T extends { hasDefault: infer U } ? U : boolean;
+        isPartitionKey: T extends { isPartitionKey: infer U } ? U : boolean;
+        isSortKey: T extends { isSortKey: infer U } ? U : boolean;
+    } & TTypeConfig
+>;
+
+export interface ColumnBuilderBase<
+    T extends ColumnBuilderBaseConfig<
+        string,
+        ColumnDataType
+    > = ColumnBuilderBaseConfig<string, ColumnDataType>,
+    TTypeConfig extends object = object,
+> {
+    _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+}
+
+export interface ColumnBuiderExtraConfig {
+    partitionKeyHasDefault?: boolean;
+}
+
+export type NotNull<T extends ColumnBuilderBase> = T & {
+    _: {
+        notNull: true;
+    };
+};
+
+export type HasDefault<T extends ColumnBuilderBase> = T & {
+    _: {
+        hasDefault: true;
+    };
+};
+
+export type HasRuntimeDefault<T extends ColumnBuilderBase> = T & {
+    _: {
+        hasRuntimeDefault: true;
+    };
+};
+
+export type IsPartitionKey<T extends ColumnBuilderBase> = T & {
+    _: {
+        isPartitionKey: true;
+        notNull: false;
+    };
+};
+
+export type IsSortKey<T extends ColumnBuilderBase> = T & {
+    _: {
+        isSortKey: true;
+        notNull: false;
+    };
+};
+
+export type $Type<T extends ColumnBuilderBase, TType> = T & {
+    _: { $type: TType };
+};
+
+export type BuildColumn<
+    TTableName extends string,
+    TBuilder extends ColumnBuilderBase,
+> = Column<
+    MakeColumnConfig<TBuilder["_"], TTableName>,
+    object,
+    Simplify<
+        Omit<TBuilder["_"], keyof MakeColumnConfig<TBuilder["_"], TTableName>>
+    >
+>;
+
+export type BuildColumns<
+    TTableName extends string,
+    TConfigMap extends Record<string, ColumnBuilderBase>,
+> = Simplify<{
+    [Key in keyof TConfigMap]: BuildColumn<
+        TTableName,
+        {
+            _: Omit<TConfigMap[Key]["_"], "name"> & {
+                name: TConfigMap[Key]["_"]["name"] extends ""
+                    ? Assume<Key, string>
+                    : TConfigMap[Key]["_"]["name"];
+            };
+        }
+    >;
+}>;
+
+export abstract class ColumnBuider<
+    T extends ColumnBuilderBaseConfig<
+        string,
+        ColumnDataType
+    > = ColumnBuilderBaseConfig<string, ColumnDataType>,
+    TRuntimeConfig extends object = object,
+    TTypeConfig extends object = object,
+    TExtraConfig extends ColumnBuiderExtraConfig = ColumnBuiderExtraConfig,
+> implements ColumnBuilderBase<T, TTypeConfig>
+{
+    declare _: ColumnBuilderTypeConfig<T, TTypeConfig>;
+    public config: ColumnBuilderRuntimeConfig<T["data"], TRuntimeConfig>;
+
+    constructor(
+        name: T["name"],
+        dataType: T["dataType"],
+        columnType: T["columnType"],
+    ) {
+        this.config = {
+            name,
+            dataType,
+            columnType,
+            notNull: false,
+            default: undefined,
+            hasDefault: false,
+            isPartitionKey: false,
+            isSortKey: false,
+        } as ColumnBuilderRuntimeConfig<T["data"], TRuntimeConfig>;
+    }
+
+    default(
+        value: this["_"] extends { $type: infer U } ? U : this["_"]["data"],
+    ): HasDefault<this> {
+        this.config.default = value;
+        this.config.hasDefault = true;
+        return this as HasDefault<this>;
+    }
+
+    $defaultFn(
+        fn: () => this["_"] extends { $type: infer U } ? U : this["_"]["data"],
+    ): HasRuntimeDefault<HasDefault<this>> {
+        this.config.defaultFn = fn;
+        this.config.hasDefault = true;
+        return this as HasRuntimeDefault<HasDefault<this>>;
+    }
+
+    $onUpdateFn(
+        fn: () => this["_"] extends { $type: infer U } ? U : this["_"]["data"],
+    ): HasDefault<this> {
+        this.config.onUpdateFn = fn;
+        this.config.hasDefault = true;
+        return this as HasDefault<this>;
+    }
+
+    /**
+     * Change de data type of the column.
+     *
+     * ```ts
+     * const users = dynamoTable('users', {
+     *  details: map().$type<UserDetails>().nullable()
+     * });
+     * ```
+     */
+    $type<TType>(): $Type<this, TType> {
+        return this as $Type<this, TType>;
+    }
+
+    /** @internal */
+    getConfig() {
+        return this.config;
+    }
+
+    partitionKey(): TExtraConfig["partitionKeyHasDefault"] extends true
+        ? IsPartitionKey<HasDefault<NotNull<this>>>
+        : IsPartitionKey<NotNull<this>> {
+        this.config.isPartitionKey = true;
+        this.config.notNull = false;
+
+        return this as TExtraConfig["partitionKeyHasDefault"] extends true
+            ? IsPartitionKey<HasDefault<NotNull<this>>>
+            : IsPartitionKey<NotNull<this>>;
+    }
+
+    sortKey(): IsSortKey<this> {
+        this.config.isSortKey = true;
+        this.config.notNull = false;
+        return this as IsSortKey<this>;
+    }
+
+    /**
+     * Turns a column nullable.
+     *
+     * ```ts
+     * const users = dynamoTable('users', {
+     *  name: string().nullable()
+     * });
+     * ```
+     */
+    notNull(): NotNull<this> {
+        this.config.notNull = true;
+        return this as NotNull<this>;
+    }
+
+    /** @internal */
+    setName(name: string) {
+        if (this.config.name !== "") return;
+        this.config.name = name;
+    }
+
+    /** @internal */
+    abstract build<TTableName extends string>(
+        table: AnyTable,
+    ): Column<MakeColumnConfig<T, TTableName>>;
+}

package/src/core/column.ts

@@ -0,0 +1,167 @@
+import { INFER_MODE, NULLS, ORDER } from "@mizzle/shared";
+import type { Update } from "@mizzle/shared";
+import type {
+    ColumnBuilderBaseConfig,
+    ColumnBuilderRuntimeConfig,
+    ColumnDataType,
+} from "./column-builder";
+import type { PhysicalTable } from "./table";
+
+export type AnyColumn<
+    TPartial extends Partial<ColumnBaseConfig<string, ColumnDataType>> = Record<string, never>,
+> = Column<
+    Required<Update<ColumnBaseConfig<string, ColumnDataType>, TPartial>>
+>;
+
+export interface ColumnBaseConfig<
+    TDataType extends string,
+    TColumnType extends ColumnDataType,
+> extends ColumnBuilderBaseConfig<TDataType, TColumnType> {
+    tableName: string;
+    name: string;
+    notNull: boolean;
+    hasDefault: boolean;
+    hasRuntimeDefault: boolean;
+    isPartitionKey: boolean;
+    isSortKey: boolean;
+    validators?: Record<string, unknown>;
+}
+
+export type ColumnTypeConfig<
+    T extends ColumnBaseConfig<string, ColumnDataType>,
+    TTypeConfig extends object,
+> = T & {
+    tableName: T["tableName"];
+    name: T["name"];
+    dataType: T["dataType"];
+    columnType: T["columnType"];
+    data: T["data"];
+    notNull: T["notNull"];
+    hasDefault: T["hasDefault"];
+    hasRuntimeDefault: T["hasRuntimeDefault"];
+    isPartitionKey: T["isPartitionKey"];
+    isSortKey: T["isSortKey"];
+} & TTypeConfig;
+
+export type ColumnRuntimeConfig<
+    TData,
+    TRuntimeConfig extends object,
+> = ColumnBuilderRuntimeConfig<TData, TRuntimeConfig>;
+
+export abstract class Column<
+    T extends ColumnBaseConfig<string, ColumnDataType> = ColumnBaseConfig<
+        string,
+        ColumnDataType
+    >,
+    TRuntimeConfig extends object = object,
+    TTypeConfig extends object = object,
+> {
+    declare readonly _: ColumnTypeConfig<T, TTypeConfig>;
+
+    readonly name: string;
+    readonly primary: boolean;
+    readonly notNull: boolean;
+    readonly default: T["data"] | undefined;
+    readonly defaultFn: () => T["data"] | undefined;
+    readonly onUpdateFn: () => T["data"] | undefined;
+    readonly hasDefault: boolean;
+    readonly dataType: T["dataType"];
+    readonly columnType: T["columnType"];
+
+    protected config: ColumnRuntimeConfig<T["data"], TRuntimeConfig>;
+
+    constructor(
+        readonly table: PhysicalTable,
+        config: ColumnRuntimeConfig<T["data"], TRuntimeConfig>,
+    ) {
+        this.config = config;
+        this.name = config.name;
+        this.primary = config.partitionKey;
+        this.notNull = config.notNull;
+        this.default = config.default;
+        this.defaultFn = config.defaultFn;
+        this.onUpdateFn = config.onUpdateFn;
+        this.hasDefault = config.hasDefault;
+        this.dataType = config.dataType;
+        this.columnType = config.columnType as T["columnType"];
+    }
+
+    getDynamoType(): string {
+        return this.columnType;
+    }
+
+    mapFromDynamoValue(value: unknown): unknown {
+        return value;
+    }
+
+    mapToDynamoValue(value: unknown): unknown {
+        return value;
+    }
+}
+
+export type GetColumnData<
+    TColumn extends Column,
+    TInferMode extends "query" | "raw" = "query",
+> = TInferMode extends typeof INFER_MODE.RAW
+    ? TColumn["_"]["data"]
+    : TColumn["_"]["notNull"] extends false
+      ? TColumn["_"]["data"]
+      : TColumn["_"]["data"] | null;
+
+export type InferColumndsDataTypes<TColumns extends Record<string, Column>> = {
+    [Key in keyof TColumns]: GetColumnData<TColumns[Key]>;
+};
+
+export type IndexedExtraConfigType = {
+    order?: typeof ORDER.ASC | typeof ORDER.DESC;
+    nulls?: typeof NULLS.FIRST | typeof NULLS.LAST;
+    opClass?: string;
+};
+
+export class ExtraConfigColumn<
+    T extends ColumnBaseConfig<string, ColumnDataType> = ColumnBaseConfig<
+        string,
+        ColumnDataType
+    >,
+> extends Column<T, IndexedExtraConfigType> {
+    override getDynamoType(): string {
+        return this.getDynamoType();
+    }
+
+    indexConfig: IndexedExtraConfigType = {
+        order: this.config.order ?? ORDER.ASC,
+        nulls: this.config.nulls ?? NULLS.LAST,
+        opClass: this.config.opClass,
+    };
+
+    defaultConfig: IndexedExtraConfigType = {
+        order: ORDER.ASC,
+        nulls: NULLS.LAST,
+        opClass: undefined,
+    };
+
+    asc(): Omit<this, "asc" | "desc"> {
+        this.indexConfig.order = ORDER.ASC;
+        return this;
+    }
+
+    desc(): Omit<this, "asc" | "desc"> {
+        this.indexConfig.order = ORDER.DESC;
+        return this;
+    }
+
+    nullsFirst(): Omit<this, "nullsFirst" | "nullsLast"> {
+        this.indexConfig.nulls = NULLS.FIRST;
+        return this;
+    }
+
+    nullsLast(): Omit<this, "nullsFirst" | "nullsLast"> {
+        this.indexConfig.nulls = NULLS.LAST;
+        return this;
+    }
+
+    op(opClass: string): Omit<this, "opClass"> {
+        this.indexConfig.opClass = opClass;
+        return this;
+    }
+}

package/src/core/diff.ts

@@ -0,0 +1,50 @@
+import type { MizzleSnapshot, TableSnapshot, SchemaCurrent } from "./snapshot";
+import { generateSnapshot } from "./snapshot";
+
+export type SchemaChange = 
+  | { type: "create"; table: TableSnapshot }
+  | { type: "delete"; tableName: string }
+  | { type: "update"; tableName: string; changes: unknown[] };
+
+export function compareSchema(current: SchemaCurrent, snapshot: MizzleSnapshot): SchemaChange[] {
+    const changes: SchemaChange[] = [];
+    const currentSnapshot = generateSnapshot(current);
+    
+    const currentTables = currentSnapshot.tables;
+    const snapshotTables = snapshot.tables || {};
+    
+    const allTableNames = new Set([...Object.keys(currentTables), ...Object.keys(snapshotTables)]);
+
+    for (const tableName of allTableNames) {
+        const currentTable = currentTables[tableName];
+        const snapshotTable = snapshotTables[tableName];
+
+        if (currentTable && !snapshotTable) {
+            changes.push({ type: "create", table: currentTable });
+        } else if (!currentTable && snapshotTable) {
+            changes.push({ type: "delete", tableName });
+        } else if (currentTable && snapshotTable) {
+            if (!areSnapshotsEqual(currentTable, snapshotTable)) {
+                changes.push({ type: "update", tableName, changes: ["Changed"] });
+            }
+        }
+    }
+
+    return changes;
+}
+
+function areSnapshotsEqual(a: TableSnapshot, b: TableSnapshot): boolean {
+    const sortSnapshot = (s: TableSnapshot) => {
+        const copy = { ...s };
+        copy.AttributeDefinitions = [...(copy.AttributeDefinitions || [])].sort((x, y) => (x.AttributeName || "").localeCompare(y.AttributeName || ""));
+        if (copy.GlobalSecondaryIndexes) {
+            copy.GlobalSecondaryIndexes = [...copy.GlobalSecondaryIndexes].sort((x, y) => (x.IndexName || "").localeCompare(y.IndexName || ""));
+        }
+        if (copy.LocalSecondaryIndexes) {
+            copy.LocalSecondaryIndexes = [...copy.LocalSecondaryIndexes].sort((x, y) => (x.IndexName || "").localeCompare(y.IndexName || ""));
+        }
+        return copy;
+    }
+
+    return JSON.stringify(sortSnapshot(a)) === JSON.stringify(sortSnapshot(b));
+}