@aurios/mizzle 1.1.1 → 1.1.3

package/dist/snapshot.d.ts

@@ -0,0 +1,24 @@
+import { P as PhysicalTable, f as Entity } from './operators-BVreW0ky.js';
+import { AttributeDefinition, KeySchemaElement, GlobalSecondaryIndex, LocalSecondaryIndex } from '@aws-sdk/client-dynamodb';
+
+interface TableSnapshot {
+    TableName: string;
+    AttributeDefinitions: AttributeDefinition[];
+    KeySchema: KeySchemaElement[];
+    GlobalSecondaryIndexes?: GlobalSecondaryIndex[];
+    LocalSecondaryIndexes?: LocalSecondaryIndex[];
+}
+interface MizzleSnapshot {
+    version: string;
+    tables: Record<string, TableSnapshot>;
+}
+interface SchemaCurrent {
+    tables: PhysicalTable[];
+    entities: Entity[];
+}
+declare function saveSnapshot(dir: string, snapshot: MizzleSnapshot): Promise<void>;
+declare function loadSnapshot(dir: string): Promise<MizzleSnapshot | null>;
+declare function generateSnapshot(schema: SchemaCurrent): MizzleSnapshot;
+declare function getNextMigrationVersion(migrationsDir: string): Promise<string>;
+
+export { type MizzleSnapshot, type SchemaCurrent, type TableSnapshot, generateSnapshot, getNextMigrationVersion, loadSnapshot, saveSnapshot };

package/dist/snapshot.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"./chunk-AQVECMXP.js";import"./chunk-GPYZK4WY.js";import"./chunk-DU7UPWBW.js";export{c as generateSnapshot,d as getNextMigrationVersion,b as loadSnapshot,a as saveSnapshot};

package/dist/table.d.ts

@@ -0,0 +1 @@
+export { A as AnyTable, b as AtomicValues, f as Entity, g as EntityConfig, h as EntityWithColumns, k as InferInsertModel, l as InferModelFromColumns, m as InferSelectModel, n as InferSelectedModel, M as MapColumnName, P as PhysicalTable, q as PhysicalTableConfig, r as StrategyCallback, t as TableDefinition, u as UpdateTableConfig, V as dynamoEntity, W as dynamoTable } from './operators-BVreW0ky.js';

package/dist/table.js

@@ -0,0 +1 @@
+import{a,b,c,d}from"./chunk-GPYZK4WY.js";import"./chunk-DU7UPWBW.js";export{b as Entity,a as PhysicalTable,c as dynamoEntity,d as dynamoTable};

package/dist/transaction-RE7LXTGV.js

@@ -0,0 +1 @@
+import{R as a,S as b,T as c}from"./chunk-UM3YF5EC.js";import"./chunk-GPYZK4WY.js";import"./chunk-DU7UPWBW.js";export{a as ConditionCheckBuilder,c as TransactionExecutor,b as TransactionProxy};

package/package.json

@@ -1,41 +1,90 @@
 {
   "name": "@aurios/mizzle",
-  "version": "1.1.1",
-  "private": false,
+  "version": "1.1.3",
   "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"
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "keywords": [
+    "aws",
+    "database",
+    "dynamodb",
+    "mizzle",
+    "nosql",
+    "orm",
+    "singletable",
+    "ts",
+    "typescript"
+  ],
+  "homepage": "https://mizzle-docs.vercel.app",
+  "bugs": {
+    "url": "https://github.com/realfakenerd/mizzle/issues"
   },
+  "license": "MIT",
   "author": {
     "name": "Lucas",
     "url": "https://github.com/realfakenerd"
   },
   "repository": {
-    "url": "https://github.com/realfakenerd/mizzle"
+    "type": "git",
+    "url": "https://github.com/realfakenerd/mizzle.git",
+    "directory": "packages/mizzle"
   },
-  "scripts": {
-    "check": "tsc --noEmit",
-    "build": "tsup",
-    "lint": "eslint \"src/**/*.ts\""
+  "type": "module",
+  "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"
+    }
   },
   "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"
+    "tsup": "^8.5.1",
+    "@repo/shared": "0.0.3",
+    "@repo/vitest-config": "0.0.0",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "build": "tsup",
+    "test": "vitest run"
   }
-}
+}

package/src/builders/base.ts

@@ -1,71 +1,68 @@
 import { type IMizzleClient } from "../core/client";
 import { Entity } from "../core/table";
 import { QueryPromise } from "./query-promise";
-import { resolveTableName, mapToLogical } from "@mizzle/shared";
+import { resolveTableName, mapToLogical } from "@repo/shared";
 import { resolveStrategies, type StrategyResolution } from "../core/strategies";
 import { type Expression } from "../expressions/operators";
-import { ENTITY_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@repo/shared";
 
-export abstract class BaseBuilder<
-    TEntity extends Entity,
-    TResult,
-> extends QueryPromise<TResult> {
-    constructor(
-        protected readonly entity: TEntity,
-        protected readonly client: IMizzleClient,
-    ) {
-        super();
-    }
+export abstract class BaseBuilder<TEntity extends Entity, TResult> extends QueryPromise<TResult> {
+  constructor(
+    protected readonly entity: TEntity,
+    protected readonly client: IMizzleClient,
+  ) {
+    super();
+  }
 
-    public get tableName(): string {
-        return resolveTableName(this.entity as unknown as Entity);
-    }
+  public get tableName(): string {
+    return resolveTableName(this.entity as any);
+  }
 
-    protected get physicalTable() {
-        return this.entity[ENTITY_SYMBOLS.PHYSICAL_TABLE];
-    }
+  protected get physicalTable() {
+    return this.entity[ENTITY_SYMBOLS.PHYSICAL_TABLE];
+  }
 
-    protected resolveKeys(
-        whereClause?: Expression,
-        providedValues?: Record<string, unknown>,
-        indexName?: string,
-    ): StrategyResolution {
-        return resolveStrategies(this.entity, whereClause, providedValues, indexName);
-    }
+  protected resolveKeys(
+    whereClause?: Expression,
+    providedValues?: Record<string, unknown>,
+    indexName?: string,
+  ): StrategyResolution {
+    return resolveStrategies(this.entity, whereClause, providedValues, indexName);
+  }
 
-    protected createExpressionContext(prefix = "") {
-        const expressionAttributeNames: Record<string, string> = {};
-        const expressionAttributeValues: Record<string, unknown> = {};
-        let nameCount = 0;
-        let valueCount = 0;
+  protected createExpressionContext(prefix = "") {
+    const expressionAttributeNames: Record<string, string> = {};
+    const expressionAttributeValues: Record<string, unknown> = {};
+    let nameCount = 0;
+    let valueCount = 0;
 
-        const addName = (name: string) => {
-            const segments = name.split(".");
-            const placeholders = segments.map(segment => {
-                // Check if we already mapped this name segment to avoid redundancy?
-                // Actually, simple counter is fine for now and safer against collisions.
-                const placeholder = `#${prefix}n${nameCount++}`;
-                expressionAttributeNames[placeholder] = segment;
-                return placeholder;
-            });
-            return placeholders.join(".");
-        };
+    const addName = (name: string) => {
+      const segments = name.split(".");
+      const placeholders = segments.map((segment) => {
+        // Check if we already mapped this name segment to avoid redundancy?
+        // Actually, simple counter is fine for now and safer against collisions.
+        const placeholder = `#${prefix}n${nameCount++}`;
+        expressionAttributeNames[placeholder] = segment;
+        return placeholder;
+      });
+      return placeholders.join(".");
+    };
 
-        const addValue = (value: unknown) => {
-            const placeholder = `:${prefix}v${valueCount++}`;
-            expressionAttributeValues[placeholder] = value;
-            return placeholder;
-        };
+    const addValue = (value: unknown) => {
+      const placeholder = `:${prefix}v${valueCount++}`;
+      expressionAttributeValues[placeholder] = value;
+      return placeholder;
+    };
 
-        return {
-            expressionAttributeNames,
-            expressionAttributeValues,
-            addName,
-            addValue,
-        };
-    }
+    return {
+      expressionAttributeNames,
+      expressionAttributeValues,
+      addName,
+      addValue,
+    };
+  }
 
-    protected mapToLogical(item: Record<string, unknown>): Record<string, unknown> {
-        return mapToLogical(this.entity, item);
-    }
+  protected mapToLogical(item: Record<string, unknown>): Record<string, unknown> {
+    return mapToLogical(this.entity as any, item);
+  }
 }

package/src/builders/batch-get.ts

@@ -1,76 +1,81 @@
 import { BatchGetCommand } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@repo/shared";
 import { Entity, type InferSelectModel } from "../core/table";
 import { BaseBuilder } from "./base";
 import type { IMizzleClient } from "../core/client";
 
 export class BatchGetBuilder {
-    constructor(private client: IMizzleClient) {}
+  constructor(private client: IMizzleClient) {}
 
-    items<TEntity extends Entity>(entity: TEntity, keys: Partial<InferSelectModel<TEntity>>[]) {
-        return new BatchGetBase(entity, this.client, keys);
-    }
+  items<TEntity extends Entity>(entity: TEntity, keys: Partial<InferSelectModel<TEntity>>[]) {
+    return new BatchGetBase(entity, this.client, keys);
+  }
 }
 
 export interface BatchGetResult<T> {
-    succeeded: T[];
-    failed: Partial<T>[];
+  succeeded: T[];
+  failed: Partial<T>[];
 }
 
 export class BatchGetBase<
-    TEntity extends Entity,
-    TResult = InferSelectModel<TEntity>,
+  TEntity extends Entity,
+  TResult = InferSelectModel<TEntity>,
 > extends BaseBuilder<TEntity, BatchGetResult<TResult>> {
-    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "BatchGetBase";
-
-    constructor(
-        entity: TEntity,
-        client: IMizzleClient,
-        private keysData: Partial<InferSelectModel<TEntity>>[],
-    ) {
-        super(entity, client);
+  static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "BatchGetBase";
+
+  constructor(
+    entity: TEntity,
+    client: IMizzleClient,
+    private keysData: Partial<InferSelectModel<TEntity>>[],
+  ) {
+    super(entity, client);
+  }
+
+  public override async execute(): Promise<BatchGetResult<TResult>> {
+    const succeeded: TResult[] = [];
+    const failed: Partial<TResult>[] = [];
+
+    // Group keys by resolved DynamoDB keys
+    let currentKeys = this.keysData.map(
+      (k) => this.resolveKeys(undefined, k as Record<string, unknown>).keys,
+    );
+
+    let attempts = 0;
+    const maxBatchAttempts = 5; // Internal limit for unprocessed retries
+
+    while (currentKeys.length > 0 && attempts < maxBatchAttempts) {
+      attempts++;
+
+      const command = new BatchGetCommand({
+        RequestItems: {
+          [this.tableName]: {
+            Keys: currentKeys,
+          },
+        },
+      });
+
+      const response = (await this.client.send(command)) as {
+        Responses?: Record<string, unknown[]>;
+        UnprocessedKeys?: Record<string, { Keys?: Record<string, unknown>[] }>;
+      };
+
+      if (response.Responses?.[this.tableName]) {
+        succeeded.push(...(response.Responses[this.tableName] as TResult[]));
+      }
+
+      const unprocessed = response.UnprocessedKeys?.[this.tableName]?.Keys;
+
+      if (unprocessed && unprocessed.length > 0) {
+        currentKeys = unprocessed;
+      } else {
+        currentKeys = [];
+      }
     }
 
-    public override async execute(): Promise<BatchGetResult<TResult>> {
-        const succeeded: TResult[] = [];
-        const failed: Partial<TResult>[] = [];
-
-        // Group keys by resolved DynamoDB keys
-        let currentKeys = this.keysData.map(k => this.resolveKeys(undefined, k as Record<string, unknown>).keys);
-        
-        let attempts = 0;
-        const maxBatchAttempts = 5; // Internal limit for unprocessed retries
-
-        while (currentKeys.length > 0 && attempts < maxBatchAttempts) {
-            attempts++;
-            
-            const command = new BatchGetCommand({
-                RequestItems: {
-                    [this.tableName]: {
-                        Keys: currentKeys
-                    }
-                }
-            });
-
-            const response = await this.client.send(command) as { Responses?: Record<string, unknown[]>, UnprocessedKeys?: Record<string, { Keys?: Record<string, unknown>[] }> };
-            
-            if (response.Responses?.[this.tableName]) {
-                succeeded.push(...(response.Responses[this.tableName] as TResult[]));
-            }
-
-            const unprocessed = response.UnprocessedKeys?.[this.tableName]?.Keys;
-            
-            if (unprocessed && unprocessed.length > 0) {
-                currentKeys = unprocessed;
-            } else {
-                currentKeys = [];
-            }
-        }
-
-        if (currentKeys.length > 0) {
-            failed.push(...(currentKeys as Partial<TResult>[]));
-        }
-
-        return { succeeded, failed };
+    if (currentKeys.length > 0) {
+      failed.push(...(currentKeys as Partial<TResult>[]));
     }
+
+    return { succeeded, failed };
+  }
 }

package/src/builders/batch-write.ts

@@ -1,99 +1,102 @@
 import { BatchWriteCommand } from "@aws-sdk/lib-dynamodb";
-import { ENTITY_SYMBOLS } from "@mizzle/shared";
+import { ENTITY_SYMBOLS } from "@repo/shared";
 import { Entity, type InferInsertModel } from "../core/table";
 import { BaseBuilder } from "./base";
 import type { IMizzleClient } from "../core/client";
 import { calculateItemSize } from "../core/validation";
 import { ItemSizeExceededError } from "../core/errors";
 
-export type BatchWriteOperation<TEntity extends Entity> = 
-    | { type: "put", item: InferInsertModel<TEntity> }
-    | { type: "delete", keys: Partial<InferInsertModel<TEntity>> };
+export type BatchWriteOperation<TEntity extends Entity> =
+  | { type: "put"; item: InferInsertModel<TEntity> }
+  | { type: "delete"; keys: Partial<InferInsertModel<TEntity>> };
 
 export interface BatchWriteResult<_T> {
-    succeededCount: number;
-    failed: unknown[]; // Operations that failed after all retries
+  succeededCount: number;
+  failed: unknown[]; // Operations that failed after all retries
 }
 
 export class BatchWriteBuilder {
-    constructor(private client: IMizzleClient) {}
+  constructor(private client: IMizzleClient) {}
 
-    operations<TEntity extends Entity>(entity: TEntity, ops: BatchWriteOperation<TEntity>[]) {
-        return new BatchWriteBase(entity, this.client, ops);
-    }
+  operations<TEntity extends Entity>(entity: TEntity, ops: BatchWriteOperation<TEntity>[]) {
+    return new BatchWriteBase(entity, this.client, ops);
+  }
 }
 
-export class BatchWriteBase<
-    TEntity extends Entity,
-> extends BaseBuilder<TEntity, BatchWriteResult<InferInsertModel<TEntity>>> {
-    static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "BatchWriteBase";
-
-    constructor(
-        entity: TEntity,
-        client: IMizzleClient,
-        private ops: BatchWriteOperation<TEntity>[],
-    ) {
-        super(entity, client);
-    }
+export class BatchWriteBase<TEntity extends Entity> extends BaseBuilder<
+  TEntity,
+  BatchWriteResult<InferInsertModel<TEntity>>
+> {
+  static readonly [ENTITY_SYMBOLS.ENTITY_KIND]: string = "BatchWriteBase";
 
-    public override async execute(): Promise<BatchWriteResult<InferInsertModel<TEntity>>> {
-        let succeededCount = 0;
-        let failed: unknown[] = [];
-
-        const requests = this.ops.map(op => {
-            if (op.type === "put") {
-                const item = op.item as Record<string, unknown>;
-                
-                // Size validation
-                const size = calculateItemSize(item);
-                if (size > 400 * 1024) {
-                    throw new ItemSizeExceededError(`Item in batch exceeds the 400KB limit.`);
-                }
-
-                return {
-                    PutRequest: {
-                        Item: item
-                    }
-                };
-            } else {
-                return {
-                    DeleteRequest: {
-                        Key: op.keys as Record<string, unknown>
-                    }
-                };
-            }
-        });
-
-        let currentRequests: unknown[] = [...requests];
-        let attempts = 0;
-        const maxBatchAttempts = 5;
-
-        while (currentRequests.length > 0 && attempts < maxBatchAttempts) {
-            attempts++;
-            
-            const command = new BatchWriteCommand({
-                RequestItems: {
-                    [this.tableName]: currentRequests as any[]
-                }
-            });
-
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const response = await this.client.send(command) as { UnprocessedItems?: Record<string, any[]> };
-            
-            const unprocessed = response.UnprocessedItems?.[this.tableName] || [];
-            succeededCount += (currentRequests.length - unprocessed.length);
-
-            if (unprocessed.length > 0) {
-                currentRequests = unprocessed;
-            } else {
-                currentRequests = [];
-            }
-        }
+  constructor(
+    entity: TEntity,
+    client: IMizzleClient,
+    private ops: BatchWriteOperation<TEntity>[],
+  ) {
+    super(entity, client);
+  }
+
+  public override async execute(): Promise<BatchWriteResult<InferInsertModel<TEntity>>> {
+    let succeededCount = 0;
+    let failed: unknown[] = [];
 
-        if (currentRequests.length > 0) {
-            failed = currentRequests;
+    const requests = this.ops.map((op) => {
+      if (op.type === "put") {
+        const item = op.item as Record<string, unknown>;
+
+        // Size validation
+        const size = calculateItemSize(item);
+        if (size > 400 * 1024) {
+          throw new ItemSizeExceededError(`Item in batch exceeds the 400KB limit.`);
         }
 
-        return { succeededCount, failed };
+        return {
+          PutRequest: {
+            Item: item,
+          },
+        };
+      } else {
+        return {
+          DeleteRequest: {
+            Key: op.keys as Record<string, unknown>,
+          },
+        };
+      }
+    });
+
+    let currentRequests: unknown[] = [...requests];
+    let attempts = 0;
+    const maxBatchAttempts = 5;
+
+    while (currentRequests.length > 0 && attempts < maxBatchAttempts) {
+      attempts++;
+
+      const command = new BatchWriteCommand({
+        RequestItems: {
+          [this.tableName]: currentRequests as Record<string, unknown>[],
+        },
+      });
+
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const response = (await this.client.send(command)) as {
+        UnprocessedItems?: Record<string, any[]>;
+      };
+
+      const unprocessed = response.UnprocessedItems?.[this.tableName] || [];
+      succeededCount += currentRequests.length - unprocessed.length;
+
+      if (unprocessed.length > 0) {
+        currentRequests = unprocessed;
+      } else {
+        currentRequests = [];
+      }
     }
+
+    if (currentRequests.length > 0) {
+      failed = currentRequests;
+    }
+
+    return { succeededCount, failed };
+  }
 }