@aurios/mizzle 1.1.1 → 1.1.2

package/README.md

@@ -0,0 +1,57 @@
+# @aurios/mizzle
+
+A Drizzle-like ORM for DynamoDB. Mizzle provides a type-safe, fluent API for interacting with DynamoDB, supporting relational queries, batch operations, and transactions.
+
+## Installation
+
+```bash
+npm install @aurios/mizzle
+# or
+bun add @aurios/mizzle
+```
+
+## Usage
+
+### Initialization
+
+```ts
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { mizzle } from "@aurios/mizzle";
+
+const client = new DynamoDBClient({});
+const db = mizzle(client);
+```
+
+### Key Features
+
+- **Type-Safe Schema Definition**: Define your tables and entities with strict TypeScript types.
+- **Fluent Query Builder**: precise API for `insert`, `select`, `update`, and `delete` operations.
+- **Relational Queries**: Query related entities with `db.query`.
+- **Batch Operations**: `batchGet` and `batchWrite` support.
+- **Transactions**: Atomic operations using `db.transaction`.
+- **Automatic Type Inference**: `InferSelectModel` and `InferInsertModel` utilities.
+
+### Example
+
+```ts
+// Define your schema (simplified)
+import { dynamoTable, dynamoEntity, string } from "@aurios/mizzle";
+
+const myTable = dynamoTable("my-app-table", {
+  pk: string("pk"),
+  sk: string("sk"),
+});
+
+const users = dynamoEntity(myTable, "users", {
+  id: string("id"),
+  name: string("name"),
+  email: string("email"),
+});
+
+// Query
+const result = await db.select().from(users).where(eq(users.id, "123")).execute();
+```
+
+## License
+
+MIT

package/package.json

@@ -1,41 +1,74 @@
 {
-  "name": "@aurios/mizzle",
-  "version": "1.1.1",
-  "private": false,
-  "description": "a drizzle-like orm for dynamoDB",
-  "type": "module",
-  "main": "./src/index.ts",
-  "module": "./src/index.ts",
-  "types": "./src/index.ts",
-  "exports": {
-    ".": "./src/index.ts",
-    "./columns": "./src/columns/index.ts",
-    "./table": "./src/core/table.ts",
-    "./snapshot": "./src/core/snapshot.ts",
-    "./diff": "./src/core/diff.ts",
-    "./introspection": "./src/core/introspection.ts",
-    "./db": "./src/db.ts"
-  },
-  "author": {
-    "name": "Lucas",
-    "url": "https://github.com/realfakenerd"
-  },
-  "repository": {
-    "url": "https://github.com/realfakenerd/mizzle"
-  },
-  "scripts": {
-    "check": "tsc --noEmit",
-    "build": "tsup",
-    "lint": "eslint \"src/**/*.ts\""
-  },
-  "dependencies": {
-    "@aws-sdk/client-dynamodb": "3.962.0",
-    "@aws-sdk/lib-dynamodb": "3.962.0"
-  },
-  "devDependencies": {
-    "@mizzle/eslint-config": "workspace:*",
-    "@mizzle/shared": "workspace:*",
-    "@mizzle/tsconfig": "workspace:*",
-    "tsup": "^8.5.1"
-  }
+    "name": "@aurios/mizzle",
+    "version": "1.1.2",
+    "description": "a drizzle-like orm for dynamoDB",
+    "type": "module",
+    "homepage": "https://mizzle-docs.vercel.app",
+    "main": "./dist/index.js",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "development": "./src/index.ts"
+        },
+        "./columns": {
+            "types": "./dist/columns.d.ts",
+            "import": "./dist/columns.js",
+            "development": "./src/columns/index.ts"
+        },
+        "./table": {
+            "types": "./dist/table.d.ts",
+            "import": "./dist/table.js",
+            "development": "./src/core/table.ts"
+        },
+        "./snapshot": {
+            "types": "./dist/snapshot.d.ts",
+            "import": "./dist/snapshot.js",
+            "development": "./src/core/snapshot.ts"
+        },
+        "./diff": {
+            "types": "./dist/diff.d.ts",
+            "import": "./dist/diff.js",
+            "development": "./src/core/diff.ts"
+        },
+        "./introspection": {
+            "types": "./dist/introspection.d.ts",
+            "import": "./dist/introspection.js",
+            "development": "./src/core/introspection.ts"
+        },
+        "./db": {
+            "types": "./dist/db.d.ts",
+            "import": "./dist/db.js",
+            "development": "./src/db.ts"
+        }
+    },
+    "author": {
+        "name": "Lucas",
+        "url": "https://github.com/realfakenerd"
+    },
+    "repository": {
+        "url": "git+https://github.com/realfakenerd/mizzle",
+        "type": "git",
+        "directory": "packages/mizzle"
+    },
+    "bugs": {
+        "url": "https://github.com/realfakenerd/mizzle/issues"
+    },
+    "scripts": {
+        "check": "tsc --noEmit",
+        "build": "tsup",
+        "lint": "bunx oxlint --type-aware src",
+        "prepublishOnly": "bun run build"
+    },
+    "dependencies": {
+        "@aws-sdk/client-dynamodb": "3.962.0",
+        "@aws-sdk/lib-dynamodb": "3.962.0"
+    },
+    "devDependencies": {
+        "@mizzle/shared": "workspace:*",
+        "@mizzle/tsconfig": "workspace:*",
+        "tsup": "^8.5.1"
+    }
 }

package/src/builders/base.ts

@@ -18,7 +18,7 @@ export abstract class BaseBuilder<
     }
 
     public get tableName(): string {
-        return resolveTableName(this.entity as unknown as Entity);
+        return resolveTableName(this.entity as any);
     }
 
     protected get physicalTable() {
@@ -66,6 +66,6 @@ export abstract class BaseBuilder<
     }
 
     protected mapToLogical(item: Record<string, unknown>): Record<string, unknown> {
-        return mapToLogical(this.entity, item);
+        return mapToLogical(this.entity as any, item);
     }
 }

package/src/builders/batch-write.ts

@@ -73,7 +73,7 @@ export class BatchWriteBase<
             
             const command = new BatchWriteCommand({
                 RequestItems: {
-                    [this.tableName]: currentRequests as any[]
+                    [this.tableName]: currentRequests as Record<string, unknown>[]
                 }
             });
 

package/src/builders/delete.ts

@@ -65,7 +65,7 @@ export class DeleteBuilder<
             ReturnValues: this._returnValues,
         });
 
-        const response = await this.client.send(command);
+        const response = await this.client.send(command) as any;
         return response.Attributes as TResult;
     }
 }

package/src/builders/insert.ts

@@ -14,7 +14,7 @@ export class InsertBuilder<TEntity extends Entity> {
     constructor(
         private entity: TEntity,
         private client: IMizzleClient,
-    ) {}
+    ) { }
 
     /**
      * Sets the values to be inserted into the database.
@@ -71,7 +71,7 @@ export class InsertBase<
     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
@@ -164,11 +164,11 @@ export class InsertBase<
             }
 
             const finalValue = item[key];
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            item[key] = typeof (col as any).mapToDynamoValue === "function" 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                ? (col as any).mapToDynamoValue(finalValue) 
-                : finalValue;
+
+            // 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)) {

package/src/builders/relational-builder.ts

@@ -79,7 +79,7 @@ export class RelationnalQueryBuilder<T extends Entity> {
                 if (options.where) {
                         const columns = (this.table._?.columns || (this.table as unknown as Record<string, Column>)) as Record<string, Column>;
                         if (typeof options.where === 'function') {
-                                condition = (options.where as WhereCallback<T>)(columns as any, operators);
+                                condition = (options.where as WhereCallback<T>)(columns as unknown as Record<string, Column>, operators);
                         } else {
                                 condition = options.where as Condition;
                         }
@@ -106,10 +106,10 @@ export class RelationnalQueryBuilder<T extends Entity> {
                         
                         // Map physical attributes back to logical names for the parser
                         // We need a helper since we are not inheriting from BaseBuilder here
-                        const logicalItems = rawItems.map(item => mapToLogical(this.table, item));
+                        const logicalItems = rawItems.map(item => mapToLogical(this.table as any, item));
 
                         const parser = new ItemCollectionParser(this.schema);
-                        results = parser.parse(logicalItems as any, this.entityName, (options.with || options.include) as Record<string, boolean | object>);
+                        results = parser.parse(logicalItems as Record<string, unknown>[], this.entityName, (options.with || options.include) as Record<string, boolean | object>);
 
                         if (options.limit) {
                                 results = results.slice(0, options.limit);
@@ -147,7 +147,7 @@ export class RelationnalQueryBuilder<T extends Entity> {
                                         const targetEntityName = Object.entries(this.schema!.entities).find(([_, m]) => m.entity === targetEntity)?.[0];
 
                                         // Map result to logical names for target strategy resolution
-                                        const logicalValues = mapToLogical(this.table, result);
+                                        const logicalValues = mapToLogical(this.table as any, result);
 
                                         let finalLogicalValues = logicalValues;
                                         if (relation.config.fields && relation.config.references) {

package/src/builders/select.ts

@@ -3,7 +3,7 @@ import {
     QueryCommand,
     ScanCommand,
 } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@mizzle/shared";
 import { Column } from "../core/column";
 import type { SelectedFields as SelectedFieldsBase } from "../core/operations";
 import { 
@@ -159,28 +159,27 @@ export class SelectBase<
      * @returns An AsyncIterableIterator for the query results.
      */
     iterator(): AsyncIterableIterator<TResult> {
-        const self = this;
-        return (async function* () {
+        return (async function* (this: SelectBase<TEntity, TSelection, TResult>) {
+            let lastEvaluatedKey: Record<string, unknown> | undefined;
             let count = 0;
-            let lastEvaluatedKey: Record<string, any> | undefined = undefined;
 
             do {
-                const result = await self.fetchPage(lastEvaluatedKey);
+                const result = await this.fetchPage(lastEvaluatedKey);
                 
                 for (const item of result.items) {
                     yield item;
                     count++;
-                    if (self._limitVal !== undefined && count >= self._limitVal) {
+                    if (this._limitVal !== undefined && count >= this._limitVal) {
                         return;
                     }
                 }
 
                 lastEvaluatedKey = result.lastEvaluatedKey;
             } while (lastEvaluatedKey);
-        })();
+        }).bind(this)();
     }
 
-    private async fetchPage(exclusiveStartKey?: Record<string, any>): Promise<{ items: TResult[], lastEvaluatedKey?: Record<string, any> }> {
+    private async fetchPage(exclusiveStartKey?: Record<string, unknown>): Promise<{ items: TResult[], lastEvaluatedKey?: Record<string, unknown> }> {
         const resolution = this.resolveKeys(this._whereClause, undefined, this._forcedIndexName);
 
         if (resolution.hasPartitionKey && resolution.hasSortKey && !resolution.indexName && !exclusiveStartKey) {
@@ -211,14 +210,14 @@ export class SelectBase<
             ConsistentRead: this._consistentReadVal,
         });
 
-        const result = await this.client.send(command);
+        const result = await this.client.send(command) as any;
         return result.Item ? ([this.mapToLogical(result.Item)] as TResult[]) : [];
     }
 
     private async executeQuery(
         resolution: StrategyResolution,
-        exclusiveStartKey?: Record<string, any>,
-    ): Promise<{ items: TResult[], lastEvaluatedKey?: Record<string, any> }> {
+        exclusiveStartKey?: Record<string, unknown>,
+    ): Promise<{ items: TResult[], lastEvaluatedKey?: Record<string, unknown> }> {
         const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = this.createExpressionContext();
 
         const keyParts: string[] = [];
@@ -247,14 +246,14 @@ export class SelectBase<
             ExclusiveStartKey: exclusiveStartKey,
         });
 
-        const response = await this.client.send(command);
+        const response = await this.client.send(command) as any;
         return {
-            items: (response.Items || []).map((item: any) => this.mapToLogical(item)) as TResult[],
+            items: (response.Items || []).map((item: Record<string, unknown>) => this.mapToLogical(item)) as TResult[],
             lastEvaluatedKey: response.LastEvaluatedKey,
         };
     }
 
-    private async executeScan(exclusiveStartKey?: Record<string, any>): Promise<{ items: TResult[], lastEvaluatedKey?: Record<string, any> }> {
+    private async executeScan(exclusiveStartKey?: Record<string, unknown>): Promise<{ items: TResult[], lastEvaluatedKey?: Record<string, unknown> }> {
         const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = this.createExpressionContext();
 
         const filterExpression = this._whereClause 
@@ -271,9 +270,9 @@ export class SelectBase<
             ExclusiveStartKey: exclusiveStartKey,
         });
 
-        const response = await this.client.send(command);
+        const response = await this.client.send(command) as any;
         return {
-            items: (response.Items || []).map((item: any) => this.mapToLogical(item)) as TResult[],
+            items: (response.Items || []).map((item: Record<string, unknown>) => this.mapToLogical(item)) as TResult[],
             lastEvaluatedKey: response.LastEvaluatedKey,
         };
     }

package/src/builders/transaction.ts

@@ -6,7 +6,7 @@ import { DeleteBuilder } from "./delete";
 import { Expression } from "../expressions/operators";
 import { BaseBuilder } from "./base";
 import type { IMizzleClient } from "../core/client";
-import { ENTITY_SYMBOLS, TABLE_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@mizzle/shared";
 import { buildExpression } from "../expressions/builder";
 import { buildUpdateExpressionString } from "../expressions/update-builder";
 import { TransactionFailedError } from "../core/errors";
@@ -71,7 +71,7 @@ export class TransactionProxy {
 export class TransactionExecutor {
     constructor(private client: IMizzleClient) {}
 
-    async execute(token: string, operations: any[]): Promise<void> {
+    async execute(token: string, operations: BaseBuilder<Entity, unknown>[]): Promise<void> {
         const transactItems = operations.map(op => this.mapToTransactItem(op));
 
         const command = new TransactWriteCommand({
@@ -81,14 +81,15 @@ export class TransactionExecutor {
 
         try {
             await this.client.send(command);
-        } catch (error: any) {
-            if (error.name === "TransactionCanceledException" || error.__type?.includes("TransactionCanceledException")) {
-                const reasons = (error.CancellationReasons || []).map((reason: any, index: number) => ({
+        } catch (error: unknown) {
+            const err = error as Error & { __type?: string; CancellationReasons?: Record<string, unknown>[] };
+            if (err.name === "TransactionCanceledException" || err.__type?.includes("TransactionCanceledException")) {
+                const reasons = (err.CancellationReasons || []).map((reason: Record<string, unknown>, index: number) => ({
                     index,
-                    code: reason.Code,
-                    message: reason.Message,
-                    item: reason.Item
-                })).filter((reason: any) => reason.code !== "None");
+                    code: reason.Code as string,
+                    message: reason.Message as string,
+                    item: reason.Item as Record<string, unknown> | undefined
+                })).filter((reason) => reason.code !== "None");
                 
                 throw new TransactionFailedError("Transaction canceled by server.", reasons);
             }
@@ -96,24 +97,24 @@ export class TransactionExecutor {
         }
     }
 
-    private mapToTransactItem(builder: any): any {
-        const kind = builder.constructor[ENTITY_SYMBOLS.ENTITY_KIND];
+    private mapToTransactItem(builder: BaseBuilder<Entity, unknown>): Record<string, unknown> {
+        const kind = (builder.constructor as unknown as { [ENTITY_SYMBOLS.ENTITY_KIND]: string })[ENTITY_SYMBOLS.ENTITY_KIND];
 
         switch (kind) {
             case "InsertBase":
-                return { Put: this.mapPut(builder) };
+                return { Put: this.mapPut(builder as InsertBase<Entity, unknown>) };
             case "UpdateBuilder":
-                return { Update: this.mapUpdate(builder) };
+                return { Update: this.mapUpdate(builder as UpdateBuilder<Entity, unknown>) };
             case "DeleteBuilder":
-                return { Delete: this.mapDelete(builder) };
+                return { Delete: this.mapDelete(builder as DeleteBuilder<Entity, unknown>) };
             case "ConditionCheckBuilder":
-                return { ConditionCheck: this.mapConditionCheck(builder) };
+                return { ConditionCheck: this.mapConditionCheck(builder as ConditionCheckBuilder<Entity>) };
             default:
                 throw new Error(`Unsupported transaction operation: ${kind}`);
         }
     }
 
-    private mapPut(builder: InsertBase<any, any>): any {
+    private mapPut(builder: InsertBase<Entity, unknown>): Record<string, unknown> {
         const finalItem = builder.buildItem();
 
         return {
@@ -122,7 +123,7 @@ export class TransactionExecutor {
         };
     }
 
-    private mapUpdate(builder: UpdateBuilder<any, any>): any {
+    private mapUpdate(builder: UpdateBuilder<Entity, unknown>): Record<string, unknown> {
         const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = builder.createExpressionContext("up_");
         const updateExpression = buildUpdateExpressionString(builder.state, addName, addValue);
         
@@ -141,7 +142,7 @@ export class TransactionExecutor {
         };
     }
 
-    private mapDelete(builder: DeleteBuilder<any, any>): any {
+    private mapDelete(builder: DeleteBuilder<Entity, unknown>): Record<string, unknown> {
         const resolution = builder.resolveKeys(undefined, builder.keys);
         return {
             TableName: builder.tableName,
@@ -149,7 +150,7 @@ export class TransactionExecutor {
         };
     }
 
-    private mapConditionCheck(builder: ConditionCheckBuilder<any>): any {
+    private mapConditionCheck(builder: ConditionCheckBuilder<Entity>): Record<string, unknown> {
         const { expressionAttributeNames, expressionAttributeValues, addName, addValue } = builder.createExpressionContext("cc_");
         
         const resolution = builder.resolveKeys(builder.whereClause);

package/src/builders/update.ts

@@ -1,6 +1,7 @@
 import { UpdateCommand } from "@aws-sdk/lib-dynamodb";
 import { ENTITY_SYMBOLS } from "@mizzle/shared";
 import { Entity, type InferInsertModel } from "../core/table";
+import { Column } from "../core/column";
 import { type Expression } from "../expressions/operators";
 import { BaseBuilder } from "./base";
 import { type IMizzleClient } from "../core/client";
@@ -59,7 +60,7 @@ export class UpdateBuilder<
      * @returns The current builder instance for chaining.
      */
     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>);
+        partitionUpdateValues(values as Record<string, unknown | UpdateAction>, this._state, this.entity[ENTITY_SYMBOLS.COLUMNS] as unknown as Record<string, Column>);
         return this;
     }
 
@@ -71,9 +72,9 @@ export class UpdateBuilder<
      * @returns The current builder instance for chaining.
      */
     add(values: Partial<InferInsertModel<TEntity>>): this {
-        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
+        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as unknown as Record<string, Column>;
         for (const [key, val] of Object.entries(values)) {
-            const col = columns[key];
+            const col = columns[key] as unknown as { mapToDynamoValue?: (v: unknown) => unknown };
             this._state.add[key] = (col && typeof col.mapToDynamoValue === "function") 
                 ? col.mapToDynamoValue(val) 
                 : val;
@@ -101,9 +102,9 @@ export class UpdateBuilder<
      * @returns The current builder instance for chaining.
      */
     delete(values: Partial<InferInsertModel<TEntity>>): this {
-        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
+        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as unknown as Record<string, Column>;
         for (const [key, val] of Object.entries(values)) {
-            const col = columns[key];
+            const col = columns[key] as unknown as { mapToDynamoValue?: (v: unknown) => unknown };
             this._state.delete[key] = (col && typeof col.mapToDynamoValue === "function") 
                 ? col.mapToDynamoValue(val) 
                 : val;
@@ -155,12 +156,13 @@ export class UpdateBuilder<
      * @throws {ItemSizeExceededError} if the update exceeds 400KB.
      */
     public override async execute(): Promise<TResult> {
-        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, any>;
+        const columns = this.entity[ENTITY_SYMBOLS.COLUMNS] as unknown as Record<string, Column>;
         for (const [key, col] of Object.entries(columns)) {
-            if (col.onUpdateFn && !this._state.set[key] && !this._state.remove.includes(key)) {
-                const val = col.onUpdateFn();
+            const column = col as unknown as { onUpdateFn?: () => unknown, mapToDynamoValue?: (v: unknown) => unknown };
+            if (column.onUpdateFn && !this._state.set[key] && !this._state.remove.includes(key)) {
+                const val = column.onUpdateFn();
                 this._state.set[key] = { 
-                    value: typeof col.mapToDynamoValue === "function" ? col.mapToDynamoValue(val) : val 
+                    value: typeof column.mapToDynamoValue === "function" ? column.mapToDynamoValue(val) : val 
                 };
             }
         }
@@ -199,7 +201,7 @@ export class UpdateBuilder<
             ReturnValues: this._returnValues,
         });
 
-        const response = await this.client.send(command);
+        const response = await this.client.send(command) as any;
         return response.Attributes as TResult;
     }
 

package/src/core/parser.ts

@@ -5,7 +5,7 @@ import { Entity } from "./table";
 import { Column } from "./column";
 
 interface MinimalPhysicalTable {
-    [TABLE_SYMBOLS.PARTITION_KEY]: Column;
+    [TABLE_SYMBOLS.PARTITION_KEY]: Column | undefined;
     [TABLE_SYMBOLS.SORT_KEY]?: Column;
 }
 
@@ -78,8 +78,9 @@ export class ItemCollectionParser {
             KeyStrategy
         >;
         const physicalTable = entity[ENTITY_SYMBOLS.PHYSICAL_TABLE] as unknown as MinimalPhysicalTable;
+        if (!physicalTable || !physicalTable[TABLE_SYMBOLS.PARTITION_KEY]) return false;
 
-        const pkName = physicalTable[TABLE_SYMBOLS.PARTITION_KEY].name;
+        const pkName = physicalTable[TABLE_SYMBOLS.PARTITION_KEY]!.name;
         const skName = physicalTable[TABLE_SYMBOLS.SORT_KEY]?.name;
 
         const pkMatch = this.matchStrategy(item[pkName], strategies.pk);

package/src/core/relations.ts

@@ -167,13 +167,14 @@ export function defineRelations<TSchema extends Record<string, Entity>>(
  */
 export function defineRelations(
     first: Entity | Record<string, Entity>,
-    callback: Function
-): any {
+    callback: RelationsCallback | MultiRelationsCallback<any>
+): RelationsDefinition | MultiRelationsDefinition {
     if (first instanceof Entity) {
         // Single entity mode
-        const config = callback({
-            one: (to: Entity, config: any) => new Relation("one", { to, ...config }),
-            many: (to: Entity, config: any) => new Relation("many", { to, ...config }),
+        const cb = callback as RelationsCallback;
+        const config = cb({
+            one: (to: Entity, config?: Omit<RelationConfig, "to">) => new Relation("one", { to, ...config }),
+            many: (to: Entity, config?: Omit<RelationConfig, "to">) => new Relation("many", { to, ...config }),
         });
 
         return {
@@ -184,24 +185,25 @@ export function defineRelations(
     } else {
         // Multi-entity mode
         const schema = first as Record<string, Entity>;
+        const cb = callback as MultiRelationsCallback<typeof schema>;
         
         // Build helpers
-        const helpers: any = {
+        const helpers: Record<string, unknown> = {
             one: {},
             many: {},
         };
 
         for (const [key, entity] of Object.entries(schema)) {
-            helpers.one[key] = (config: any) => new Relation("one", { to: entity, ...config });
-            helpers.many[key] = (config: any) => new Relation("many", { to: entity, ...config });
+            (helpers.one as Record<string, unknown>)[key] = (config?: Omit<RelationConfig, "to">) => new Relation("one", { to: entity, ...config });
+            (helpers.many as Record<string, unknown>)[key] = (config?: Omit<RelationConfig, "to">) => new Relation("many", { to: entity, ...config });
             helpers[key] = entity;
         }
 
-        const definitions = callback(helpers);
+        const definitions = cb(helpers as unknown as RelationsHelpers<typeof schema>);
 
         return {
             schema,
-            definitions,
+            definitions: definitions as Record<string, Record<string, Relation>>,
             [RELATION_SYMBOLS.RELATION_CONFIG]: true
         };
     }
@@ -242,8 +244,9 @@ export function extractMetadata(schema: Record<string, unknown>): InternalRelati
 
     // Second pass: identify relations
     for (const [, value] of Object.entries(schema)) {
-        if (value && (value as any)[RELATION_SYMBOLS.RELATION_CONFIG]) {
-            if ((value as any).entity) {
+        if (value && typeof value === 'object' && (value as Record<string | symbol, unknown>)[RELATION_SYMBOLS.RELATION_CONFIG]) {
+            const relationConfig = value as Record<string | symbol, unknown>;
+            if (relationConfig.entity) {
                 // Single entity definition
                 const definition = value as RelationsDefinition;
                 const entityEntry = Object.entries(metadata.entities).find(
@@ -254,7 +257,7 @@ export function extractMetadata(schema: Record<string, unknown>): InternalRelati
                     const [, meta] = entityEntry;
                     meta.relations = { ...meta.relations, ...definition.config };
                 }
-            } else if ((value as any).definitions) {
+            } else if (relationConfig.definitions) {
                 // Multi-entity definition
                 const multiDef = value as MultiRelationsDefinition;
                 for (const [entityName, relations] of Object.entries(multiDef.definitions)) {

package/src/core/strategies.ts

@@ -115,8 +115,8 @@ export function resolveStrategies(
     providedValues?: Record<string, unknown>,
     forcedIndexName?: string
 ): StrategyResolution {
-    const strategies = entity[ENTITY_SYMBOLS.ENTITY_STRATEGY] as unknown as Record<string, any>;
-    const physicalTable = entity[ENTITY_SYMBOLS.PHYSICAL_TABLE] as any;
+    const strategies = entity[ENTITY_SYMBOLS.ENTITY_STRATEGY] as unknown as Record<string, KeyStrategy | { pk: KeyStrategy; sk?: KeyStrategy }>;
+    const physicalTable = entity[ENTITY_SYMBOLS.PHYSICAL_TABLE] as unknown as Record<string | symbol, unknown>;
 
     const pkCol = physicalTable[TABLE_SYMBOLS.PARTITION_KEY] as Column;
     const skCol = physicalTable[TABLE_SYMBOLS.SORT_KEY] as Column | undefined;
@@ -150,9 +150,10 @@ export function resolveStrategies(
     };
 
     if (forcedIndexName) {
-        const indexes = physicalTable[TABLE_SYMBOLS.INDEXES];
+        const indexes = physicalTable[TABLE_SYMBOLS.INDEXES] as Record<string, unknown> | undefined;
         const indexBuilder = indexes?.[forcedIndexName] as { config: { pk: string; sk?: string } } | undefined;
-        const indexStrategy = strategies[forcedIndexName];
+        const strategy = strategies[forcedIndexName];
+        const indexStrategy = (strategy && 'pk' in strategy) ? strategy as { pk: KeyStrategy; sk?: KeyStrategy } : undefined;
 
         if (indexBuilder && indexStrategy) {
             // Check if availableValues already contains the PHYSICAL key
@@ -196,16 +197,18 @@ export function resolveStrategies(
         if (result.hasPartitionKey) return result;
     }
 
-    if (strategies.pk) {
-        const pkValue = resolveKeyStrategy(strategies.pk, availableValues);
+    if ('pk' in strategies && strategies.pk) {
+        const pkStrategy = strategies.pk as KeyStrategy;
+        const pkValue = resolveKeyStrategy(pkStrategy, availableValues);
         if (pkValue) {
             result.keys[pkCol.name] = pkValue;
             result.hasPartitionKey = true;
         }
     }
 
-    if (strategies.sk) {
-        const skValue = resolveKeyStrategy(strategies.sk, availableValues);
+    if ('sk' in strategies && strategies.sk) {
+        const skStrategy = strategies.sk as KeyStrategy;
+        const skValue = resolveKeyStrategy(skStrategy, availableValues);
         if (skValue) {
             if (skCol) {
                 result.keys[skCol.name] = skValue;
@@ -217,13 +220,14 @@ export function resolveStrategies(
     }
 
     if (!result.hasPartitionKey) {
-        const indexes = physicalTable[TABLE_SYMBOLS.INDEXES];
+        const indexes = physicalTable[TABLE_SYMBOLS.INDEXES] as Record<string, unknown> | undefined;
         if (indexes) {
             for (const [indexName, indexBuilderBase] of Object.entries(indexes)) {
                 const indexBuilder = indexBuilderBase as { config: { pk: string; sk?: string } };
-                const indexStrategy = strategies[indexName];
-                if (!indexStrategy) continue;
+                const strategy = strategies[indexName];
+                const indexStrategy = (strategy && 'pk' in strategy) ? strategy as { pk: KeyStrategy; sk?: KeyStrategy } : undefined;
                 
+                if (!indexStrategy) continue;
                 if (availableValues[indexBuilder.config.pk] !== undefined) {
                     result.indexName = indexName;
                     result.keys = {};

package/src/core/table.ts

@@ -244,7 +244,7 @@ export function dynamoEntity<
             normalizedStrategies[key] = { type: "prefix", segments: ["", val] };
         } else if (val && typeof val === "object" && !("type" in val && "segments" in val)) {
             // It's an index strategy object { pk, sk }
-            const indexStrategy: any = { ...val };
+            const indexStrategy: Record<string, unknown> = { ...val as object };
             if (indexStrategy.pk instanceof Column) {
                 indexStrategy.pk = { type: "prefix", segments: ["", indexStrategy.pk] };
             }

package/src/db.ts

@@ -3,6 +3,7 @@ import { DynamoDBDocumentClient } from "@aws-sdk/lib-dynamodb";
 import { InsertBuilder } from "./builders/insert";
 import { RelationnalQueryBuilder } from "./builders/relational-builder";
 import { SelectBuilder, type SelectedFields } from "./builders/select";
+import type { BaseBuilder } from "./builders/base";
 import type { Entity, InferInsertModel, InferSelectModel } from "./core/table";
 import { UpdateBuilder } from "./builders/update";
 import { DeleteBuilder } from "./builders/delete";
@@ -13,14 +14,14 @@ import { extractMetadata, type InternalRelationalSchema } from "./core/relations
 import { RetryHandler, type RetryConfig } from "./core/retry";
 import { MizzleClient, type IMizzleClient } from "./core/client";
 
-export type QuerySchema<TSchema extends Record<string, unknown>> = {
+export type QuerySchema<TSchema extends Record<string, any>> = {
     [K in keyof TSchema as TSchema[K] extends Entity ? K : never]: RelationnalQueryBuilder<TSchema[K] extends Entity ? TSchema[K] : never>;
 };
 
 /**
  * DynamoDB database instance.
  */
-export class DynamoDB<TSchema extends Record<string, unknown> = Record<string, unknown>> {
+export class DynamoDB<TSchema extends Record<string, any> = Record<string, any>> {
     private docClient: IMizzleClient;
     private schema?: InternalRelationalSchema;
     private retryConfig: RetryConfig;
@@ -200,7 +201,7 @@ export class DynamoDB<TSchema extends Record<string, unknown> = Record<string, u
      */
     async transaction(
         token: string,
-        callback: (tx: TransactionProxy) => any[] | Promise<any[]>
+        callback: (tx: TransactionProxy) => BaseBuilder<Entity, unknown>[] | Promise<BaseBuilder<Entity, unknown>[]>
     ): Promise<void> {
         const proxy = new TransactionProxy(this.docClient);
         const operations = await callback(proxy);
@@ -220,7 +221,7 @@ export class DynamoDB<TSchema extends Record<string, unknown> = Record<string, u
 /**
  * Configuration for initializing Mizzle.
  */
-export interface MizzleConfig<TSchema extends Record<string, unknown> = Record<string, unknown>> {
+export interface MizzleConfig<TSchema extends Record<string, any> = Record<string, any>> {
     /**
      * AWS DynamoDB Client instance from `@aws-sdk/client-dynamodb`.
      */
@@ -253,7 +254,7 @@ export interface MizzleConfig<TSchema extends Record<string, unknown> = Record<s
  * @param config A DynamoDBClient instance or a MizzleConfig object.
  * @returns A DynamoDB instance for performing database operations.
  */
-export function mizzle<TSchema extends Record<string, unknown> = Record<string, unknown>>(
+export function mizzle<TSchema extends Record<string, any> = Record<string, any>>(
     config: DynamoDBClient | MizzleConfig<TSchema>
 ): DynamoDB<TSchema> {
     if (config instanceof DynamoDBClient) {

package/src/expressions/builder.ts

@@ -35,8 +35,8 @@ export function buildExpression(
             return undefined;
         }
         const colName = addName(cond.column.name);
-        const mapValue = (v: unknown) => typeof (cond.column as any).mapToDynamoValue === "function" 
-            ? (cond.column as any).mapToDynamoValue(v) 
+        const mapValue = (v: unknown) => typeof (cond.column as unknown as { mapToDynamoValue: Function }).mapToDynamoValue === "function" 
+            ? (cond.column as unknown as { mapToDynamoValue: (v: unknown) => unknown }).mapToDynamoValue(v) 
             : v;
 
         if (cond.operator === "between") {
@@ -61,8 +61,8 @@ export function buildExpression(
             return undefined;
         }
         const colName = addName(cond.column.name);
-        const mapValue = (v: unknown) => typeof (cond.column as any).mapToDynamoValue === "function" 
-            ? (cond.column as any).mapToDynamoValue(v) 
+        const mapValue = (v: unknown) => typeof (cond.column as unknown as { mapToDynamoValue: Function }).mapToDynamoValue === "function" 
+            ? (cond.column as unknown as { mapToDynamoValue: (v: unknown) => unknown }).mapToDynamoValue(v) 
             : v;
 
         if (cond.operator === "attribute_exists") {

package/src/expressions/update-builder.ts

@@ -1,5 +1,5 @@
 import { type Column } from "../core/column";
-import { UpdateAction } from "./actions";
+import { UpdateAction, SetAction, AddAction, DeleteAction } from "./actions";
 
 export interface UpdateState {
     set: Record<string, { value: unknown; functionName?: string; usePathAsFirstArg?: boolean }>;
@@ -24,27 +24,29 @@ export function partitionUpdateValues(
 ): void {
     for (const [key, val] of Object.entries(values)) {
         const col = columns?.[key];
-        const mapValue = (v: unknown) => (col && typeof (col as any).mapToDynamoValue === "function")
-            ? (col as any).mapToDynamoValue(v) 
+        const mapValue = (v: unknown) => (col && typeof (col as unknown as { mapToDynamoValue: Function }).mapToDynamoValue === "function")
+            ? (col as unknown as { mapToDynamoValue: (v: unknown) => unknown }).mapToDynamoValue(v) 
             : v;
 
         if (val instanceof UpdateAction) {
             switch (val.action) {
-                case "SET":
+                case "SET": {
+                    const setVal = val as SetAction;
                     state.set[key] = {
-                        value: mapValue((val as any).value),
-                        functionName: (val as any).functionName,
-                        usePathAsFirstArg: (val as any).usePathAsFirstArg,
+                        value: mapValue(setVal.value),
+                        functionName: setVal.functionName,
+                        usePathAsFirstArg: setVal.usePathAsFirstArg,
                     };
                     break;
+                }
                 case "ADD":
-                    state.add[key] = mapValue((val as any).value);
+                    state.add[key] = mapValue((val as AddAction).value);
                     break;
                 case "REMOVE":
                     state.remove.push(key);
                     break;
                 case "DELETE":
-                    state.delete[key] = mapValue((val as any).value);
+                    state.delete[key] = mapValue((val as DeleteAction).value);
                     break;
             }
         } else if (val !== undefined) {

package/src/index.ts

@@ -13,6 +13,7 @@ export * from "./builders/relational-builder";
 export * from "./core/table";
 export * from "./core/strategies";
 export * from "./core/relations";
+export * from "./core/diff";
 export * from "./core/retry";
 export * from "./core/errors";
 export * from "./columns";

package/tsconfig.json

@@ -2,9 +2,8 @@
   "extends": "@mizzle/tsconfig/base.json",
   "compilerOptions": {
     "outDir": "./dist",
-    "baseUrl": ".",
     "paths": {
-      "@mizzle/shared": ["../shared/src/index.ts"]
+      "@mizzle/shared": ["./../shared/src/index.ts"]
     }
   },
   "include": ["src"]