@aurios/mizzle 1.1.2 → 1.1.3

package/src/core/retry.ts

@@ -1,71 +1,71 @@
 export interface RetryConfig {
-    /**
-     * Maximum number of attempts (including the initial one).
-     * @default 3
-     */
-    maxAttempts: number;
-    /**
-     * Base delay in milliseconds for exponential backoff.
-     * @default 100
-     */
-    baseDelay: number;
+  /**
+   * Maximum number of attempts (including the initial one).
+   * @default 3
+   */
+  maxAttempts: number;
+  /**
+   * Base delay in milliseconds for exponential backoff.
+   * @default 100
+   */
+  baseDelay: number;
 }
 
 const RETRYABLE_ERRORS = new Set([
-    "ProvisionedThroughputExceededException",
-    "RequestLimitExceeded",
-    "InternalServerError",
-    "ServiceUnavailable",
-    "ThrottlingException",
+  "ProvisionedThroughputExceededException",
+  "RequestLimitExceeded",
+  "InternalServerError",
+  "ServiceUnavailable",
+  "ThrottlingException",
 ]);
 
 const RETRYABLE_STATUS_CODES = new Set([500, 503]);
 
 export class RetryHandler {
-    constructor(private config: RetryConfig) {}
+  constructor(private config: RetryConfig) {}
 
-    async execute<T>(operation: () => Promise<T>): Promise<T> {
-        let lastError: unknown;
-        
-        for (let attempt = 1; attempt <= this.config.maxAttempts; attempt++) {
-            try {
-                return await operation();
-            } catch (error) {
-                lastError = error;
-                
-                if (attempt >= this.config.maxAttempts || !this.isRetryable(error)) {
-                    throw error;
-                }
-                
-                await this.delay(attempt - 1);
-            }
+  async execute<T>(operation: () => Promise<T>): Promise<T> {
+    let lastError: unknown;
+
+    for (let attempt = 1; attempt <= this.config.maxAttempts; attempt++) {
+      try {
+        return await operation();
+      } catch (error) {
+        lastError = error;
+
+        if (attempt >= this.config.maxAttempts || !this.isRetryable(error)) {
+          throw error;
         }
-        
-        throw lastError;
+
+        await this.delay(attempt - 1);
+      }
     }
 
-    private isRetryable(error: unknown): boolean {
-        if (!error || typeof error !== 'object') return false;
-        
-        const err = error as { name?: string; $metadata?: { httpStatusCode?: number } };
-        if (err.name && RETRYABLE_ERRORS.has(err.name)) {
-            return true;
-        }
+    throw lastError;
+  }
 
-        if (err.$metadata?.httpStatusCode && RETRYABLE_STATUS_CODES.has(err.$metadata.httpStatusCode)) {
-            return true;
-        }
+  private isRetryable(error: unknown): boolean {
+    if (!error || typeof error !== "object") return false;
 
-        // AWS SDK v3 specific error structure sometimes wraps things
-        return false;
+    const err = error as { name?: string; $metadata?: { httpStatusCode?: number } };
+    if (err.name && RETRYABLE_ERRORS.has(err.name)) {
+      return true;
     }
 
-    private async delay(retryCount: number): Promise<void> {
-        const base = this.config.baseDelay * Math.pow(2, retryCount);
-        const jitter = Math.random() * base; // Full jitter or equal jitter? Standard is random between 0 and base.
-        // Cap at some reasonable max if needed, but for now standard exponential + jitter
-        const delayTime = base + jitter;
-        
-        return new Promise(resolve => setTimeout(resolve, delayTime));
+    if (err.$metadata?.httpStatusCode && RETRYABLE_STATUS_CODES.has(err.$metadata.httpStatusCode)) {
+      return true;
     }
+
+    // AWS SDK v3 specific error structure sometimes wraps things
+    return false;
+  }
+
+  private async delay(retryCount: number): Promise<void> {
+    const base = this.config.baseDelay * Math.pow(2, retryCount);
+    const jitter = Math.random() * base; // Full jitter or equal jitter? Standard is random between 0 and base.
+    // Cap at some reasonable max if needed, but for now standard exponential + jitter
+    const delayTime = base + jitter;
+
+    return new Promise((resolve) => setTimeout(resolve, delayTime));
+  }
 }

package/src/core/snapshot.ts

@@ -2,21 +2,21 @@ import { join } from "path";
 import { writeFile, readFile, mkdir, readdir } from "fs/promises";
 import { existsSync } from "fs";
 import { PhysicalTable, Entity } from "./table";
-import { TABLE_SYMBOLS, ENTITY_SYMBOLS } from "@mizzle/shared";
+import { TABLE_SYMBOLS, ENTITY_SYMBOLS } from "@repo/shared";
 import { Column } from "./column";
 import type {
-    AttributeDefinition,
-    KeySchemaElement,
-    GlobalSecondaryIndex,
-    LocalSecondaryIndex,
+  AttributeDefinition,
+  KeySchemaElement,
+  GlobalSecondaryIndex,
+  LocalSecondaryIndex,
 } from "@aws-sdk/client-dynamodb";
 
 export interface TableSnapshot {
-    TableName: string;
-    AttributeDefinitions: AttributeDefinition[];
-    KeySchema: KeySchemaElement[];
-    GlobalSecondaryIndexes?: GlobalSecondaryIndex[];
-    LocalSecondaryIndexes?: LocalSecondaryIndex[];
+  TableName: string;
+  AttributeDefinitions: AttributeDefinition[];
+  KeySchema: KeySchemaElement[];
+  GlobalSecondaryIndexes?: GlobalSecondaryIndex[];
+  LocalSecondaryIndexes?: LocalSecondaryIndex[];
 }
 
 export interface MizzleSnapshot {
@@ -25,8 +25,8 @@ export interface MizzleSnapshot {
 }
 
 export interface SchemaCurrent {
-    tables: PhysicalTable[];
-    entities: Entity[];
+  tables: PhysicalTable[];
+  entities: Entity[];
 }
 
 const SNAPSHOT_FILENAME = "snapshot.json";
@@ -49,144 +49,145 @@ export async function loadSnapshot(dir: string): Promise<MizzleSnapshot | null>
 }
 
 export function generateSnapshot(schema: SchemaCurrent): MizzleSnapshot {
-    const tables: Record<string, TableSnapshot> = {};
-    
-    for (const table of schema.tables) {
-        const associatedEntities = schema.entities.filter(e => e[ENTITY_SYMBOLS.PHYSICAL_TABLE] === table);
-        const tableSnapshot = physicalTableToSnapshot(table, associatedEntities);
-        tables[tableSnapshot.TableName] = tableSnapshot;
-    }
-    
-    return {
-        version: "1",
-        tables
-    };
+  const tables: Record<string, TableSnapshot> = {};
+
+  for (const table of schema.tables) {
+    const associatedEntities = schema.entities.filter(
+      (e) => e[ENTITY_SYMBOLS.PHYSICAL_TABLE] === table,
+    );
+    const tableSnapshot = physicalTableToSnapshot(table, associatedEntities);
+    tables[tableSnapshot.TableName] = tableSnapshot;
+  }
+
+  return {
+    version: "1",
+    tables,
+  };
 }
 
 export async function getNextMigrationVersion(migrationsDir: string): Promise<string> {
-    if (!existsSync(migrationsDir)) return "0000";
-    
-    const files = await readdir(migrationsDir);
-    let maxVersion = -1;
-    
-    for (const file of files) {
-        if (!file.endsWith(".ts")) continue;
-        const match = file.match(/^(\d{4})_/);
-        if (match) {
-            const version = parseInt(match[1]!, 10);
-            if (version > maxVersion) maxVersion = version;
-        }
+  if (!existsSync(migrationsDir)) return "0000";
+
+  const files = await readdir(migrationsDir);
+  let maxVersion = -1;
+
+  for (const file of files) {
+    if (!file.endsWith(".ts")) continue;
+    const match = file.match(/^(\d{4})_/);
+    if (match) {
+      const version = parseInt(match[1]!, 10);
+      if (version > maxVersion) maxVersion = version;
     }
-    
-    if (maxVersion === -1) return "0000";
-    return (maxVersion + 1).toString().padStart(4, "0");
+  }
+
+  if (maxVersion === -1) return "0000";
+  return (maxVersion + 1).toString().padStart(4, "0");
 }
 
 function physicalTableToSnapshot(table: PhysicalTable, entities: Entity[]): TableSnapshot {
-    const tableName = table[TABLE_SYMBOLS.TABLE_NAME];
-    const attributeDefinitionsMap = new Map<string, string>(); // Name -> Type
+  const tableName = table[TABLE_SYMBOLS.TABLE_NAME];
+  const attributeDefinitionsMap = new Map<string, string>(); // Name -> Type
 
-    // PK
-    const pk = table[TABLE_SYMBOLS.PARTITION_KEY] as Column;
-    attributeDefinitionsMap.set(pk.name, pk.getDynamoType());
+  // PK
+  const pk = table[TABLE_SYMBOLS.PARTITION_KEY] as Column;
+  attributeDefinitionsMap.set(pk.name, pk.getDynamoType());
 
-    // SK
-    const sk = table[TABLE_SYMBOLS.SORT_KEY] as Column | undefined;
-    if (sk) {
-        attributeDefinitionsMap.set(sk.name, sk.getDynamoType());
-    }
+  // SK
+  const sk = table[TABLE_SYMBOLS.SORT_KEY] as Column | undefined;
+  if (sk) {
+    attributeDefinitionsMap.set(sk.name, sk.getDynamoType());
+  }
 
-    const keySchema: KeySchemaElement[] = [
-        { AttributeName: pk.name, KeyType: "HASH" }
-    ];
-    if (sk) {
-        keySchema.push({ AttributeName: sk.name, KeyType: "RANGE" });
-    }
+  const keySchema: KeySchemaElement[] = [{ AttributeName: pk.name, KeyType: "HASH" }];
+  if (sk) {
+    keySchema.push({ AttributeName: sk.name, KeyType: "RANGE" });
+  }
 
-    const gsis: GlobalSecondaryIndex[] = [];
-    const lsis: LocalSecondaryIndex[] = [];
-
-    const indexes = table[TABLE_SYMBOLS.INDEXES] || {};
-    for (const [indexName, indexBuilder] of Object.entries(indexes)) {
-        const type = (indexBuilder as { type: string }).type;
-        const config = (indexBuilder as { config: { pk?: string; sk?: string } }).config;
-
-        if (type === 'gsi') {
-            if (config.pk) {
-                const pkType = resolveColumnType(config.pk, table, entities);
-                attributeDefinitionsMap.set(config.pk, pkType);
-            }
-            if (config.sk) {
-                const skType = resolveColumnType(config.sk, table, entities);
-                attributeDefinitionsMap.set(config.sk, skType);
-            }
-
-            const gsiDef: GlobalSecondaryIndex = {
-                IndexName: indexName,
-                KeySchema: [
-                    { AttributeName: config.pk!, KeyType: "HASH" }
-                ],
-                Projection: { ProjectionType: "ALL" }
-            };
-            if (config.sk) {
-                gsiDef.KeySchema!.push({ AttributeName: config.sk, KeyType: "RANGE" });
-            }
-            gsis.push(gsiDef);
-
-        } else if (type === 'lsi') {
-             if (config.sk) {
-                const skType = resolveColumnType(config.sk, table, entities);
-                attributeDefinitionsMap.set(config.sk, skType);
-            }
-
-             const lsiDef: LocalSecondaryIndex = {
-                IndexName: indexName,
-                KeySchema: [
-                    { AttributeName: pk.name, KeyType: "HASH" },
-                    { AttributeName: config.sk!, KeyType: "RANGE" }
-                ],
-                Projection: { ProjectionType: "ALL" }
-             };
-             lsis.push(lsiDef);
-        }
+  const gsis: GlobalSecondaryIndex[] = [];
+  const lsis: LocalSecondaryIndex[] = [];
+
+  const indexes = table[TABLE_SYMBOLS.INDEXES] || {};
+  for (const [indexName, indexBuilder] of Object.entries(indexes)) {
+    const type = (indexBuilder as { type: string }).type;
+    const config = (indexBuilder as { config: { pk?: string; sk?: string } }).config;
+
+    if (type === "gsi") {
+      if (config.pk) {
+        const pkType = resolveColumnType(config.pk, table, entities);
+        attributeDefinitionsMap.set(config.pk, pkType);
+      }
+      if (config.sk) {
+        const skType = resolveColumnType(config.sk, table, entities);
+        attributeDefinitionsMap.set(config.sk, skType);
+      }
+
+      const gsiDef: GlobalSecondaryIndex = {
+        IndexName: indexName,
+        KeySchema: [{ AttributeName: config.pk!, KeyType: "HASH" }],
+        Projection: { ProjectionType: "ALL" },
+      };
+      if (config.sk) {
+        gsiDef.KeySchema!.push({ AttributeName: config.sk, KeyType: "RANGE" });
+      }
+      gsis.push(gsiDef);
+    } else if (type === "lsi") {
+      if (config.sk) {
+        const skType = resolveColumnType(config.sk, table, entities);
+        attributeDefinitionsMap.set(config.sk, skType);
+      }
+
+      const lsiDef: LocalSecondaryIndex = {
+        IndexName: indexName,
+        KeySchema: [
+          { AttributeName: pk.name, KeyType: "HASH" },
+          { AttributeName: config.sk!, KeyType: "RANGE" },
+        ],
+        Projection: { ProjectionType: "ALL" },
+      };
+      lsis.push(lsiDef);
     }
+  }
 
-    const attributeDefinitions = Array.from(attributeDefinitionsMap.entries()).map(([name, type]) => ({
-        AttributeName: name,
-        AttributeType: type as "S" | "N" | "B"
-    })).sort((a, b) => a.AttributeName.localeCompare(b.AttributeName));
+  const attributeDefinitions = Array.from(attributeDefinitionsMap.entries())
+    .map(([name, type]) => ({
+      AttributeName: name,
+      AttributeType: type as "S" | "N" | "B",
+    }))
+    .sort((a, b) => a.AttributeName.localeCompare(b.AttributeName));
 
-    gsis.sort((a, b) => (a.IndexName || "").localeCompare(b.IndexName || ""));
-    lsis.sort((a, b) => (a.IndexName || "").localeCompare(b.IndexName || ""));
+  gsis.sort((a, b) => (a.IndexName || "").localeCompare(b.IndexName || ""));
+  lsis.sort((a, b) => (a.IndexName || "").localeCompare(b.IndexName || ""));
 
-    const result: TableSnapshot = {
-        TableName: tableName as string,
-        AttributeDefinitions: attributeDefinitions,
-        KeySchema: keySchema,
-    };
+  const result: TableSnapshot = {
+    TableName: tableName as string,
+    AttributeDefinitions: attributeDefinitions,
+    KeySchema: keySchema,
+  };
 
-    if (gsis.length > 0) result.GlobalSecondaryIndexes = gsis;
-    if (lsis.length > 0) result.LocalSecondaryIndexes = lsis;
+  if (gsis.length > 0) result.GlobalSecondaryIndexes = gsis;
+  if (lsis.length > 0) result.LocalSecondaryIndexes = lsis;
 
-    return result;
+  return result;
 }
 
 function resolveColumnType(columnName: string, table: PhysicalTable, entities: Entity[]): string {
-    const pk = table[TABLE_SYMBOLS.PARTITION_KEY] as Column;
-    if (pk.name === columnName) return pk.getDynamoType();
-    
-    const sk = table[TABLE_SYMBOLS.SORT_KEY] as Column | undefined;
-    if (sk && sk.name === columnName) return sk.getDynamoType();
-
-    for (const entity of entities) {
-        const columns = entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, Column> | undefined;
-        if (columns) {
-            const col = columns[columnName];
-            if (col) {
-                return col.getDynamoType();
-            }
-        }
+  const pk = table[TABLE_SYMBOLS.PARTITION_KEY] as Column;
+  if (pk.name === columnName) return pk.getDynamoType();
+
+  const sk = table[TABLE_SYMBOLS.SORT_KEY] as Column | undefined;
+  if (sk && sk.name === columnName) return sk.getDynamoType();
+
+  for (const entity of entities) {
+    const columns = entity[ENTITY_SYMBOLS.COLUMNS] as Record<string, Column> | undefined;
+    if (columns) {
+      const col = columns[columnName];
+      if (col) {
+        return col.getDynamoType();
+      }
     }
+  }
 
-    throw new Error(`Could not resolve type for column '${columnName}' in table '${table[TABLE_SYMBOLS.TABLE_NAME]}'. Ensure it is defined in an Entity.`);
+  throw new Error(
+    `Could not resolve type for column '${columnName}' in table '${table[TABLE_SYMBOLS.TABLE_NAME]}'. Ensure it is defined in an Entity.`,
+  );
 }