@aurios/mizzling 1.1.1 → 1.1.3

package/src/commands/generate.ts

@@ -1,6 +1,11 @@
 import { type MizzleConfig } from "../config";
 import { discoverSchema } from "../discovery";
-import { loadSnapshot, saveSnapshot, generateSnapshot, getNextMigrationVersion } from "@aurios/mizzle/snapshot";
+import {
+  loadSnapshot,
+  saveSnapshot,
+  generateSnapshot,
+  getNextMigrationVersion,
+} from "@aurios/mizzle/snapshot";
 import { compareSchema, type SchemaChange } from "@aurios/mizzle/diff";
 import { join } from "path";
 import { writeFile, mkdir } from "fs/promises";
@@ -8,102 +13,102 @@ import { existsSync } from "fs";
 import { text, isCancel, cancel, intro, outro } from "@clack/prompts";
 
 interface GenerateOptions {
-    config: MizzleConfig;
-    name?: string;
-    discoverSchema?: typeof discoverSchema;
+  config: MizzleConfig;
+  name?: string;
+  discoverSchema?: typeof discoverSchema;
 }
 
 export async function generateCommand(options: GenerateOptions) {
-    intro("Mizzle Generate");
-    const { config } = options;
-    const discover = options.discoverSchema || discoverSchema;
-
-    try {
-        // 1. Discover Schema
-        const schema = await discover(config); // Returns { tables, entities }
-        
-        // 2. Load Snapshot
-        const migrationsDir = config.out;
-        const existingSnapshot = await loadSnapshot(migrationsDir) || { version: "0", tables: {} };
-
-        // 3. Compare
-        const currentSnapshot = generateSnapshot(schema);
-        const changes = compareSchema(schema, existingSnapshot);
-
-        if (changes.length === 0) {
-            outro("No changes detected.");
-            return;
-        }
-
-        console.log(`Detected ${changes.length} changes.`);
-
-        // 4. Generate Migration Script
-        const version = await getNextMigrationVersion(migrationsDir);
-        
-        let name = options.name;
-        if (!name) {
-            name = await text({
-                message: "Enter migration name",
-                placeholder: "init",
-                initialValue: "migration",
-                validate(value) {
-                    if (value.length === 0) return "Name is required";
-                }
-            }) as string;
-        }
-
-        if (isCancel(name)) {
-            cancel("Operation cancelled.");
-            return;
-        }
-
-        const filename = `${version}_${name}.ts`;
-        if (!existsSync(migrationsDir)) {
-            await mkdir(migrationsDir, { recursive: true });
-        }
-        const filePath = join(migrationsDir, filename);
-
-        const scriptContent = generateMigrationScript(changes);
-        await writeFile(filePath, scriptContent);
-        console.log(`Created migration: ${filename}`);
-
-        // 5. Save new Snapshot
-        await saveSnapshot(migrationsDir, currentSnapshot);
-        outro("Updated snapshot.json");
-    } catch (error) {
-        console.error("Error generating migration:", error);
-        process.exit(1);
+  intro("Mizzle Generate");
+  const { config } = options;
+  const discover = options.discoverSchema || discoverSchema;
+
+  try {
+    // 1. Discover Schema
+    const schema = await discover(config); // Returns { tables, entities }
+
+    // 2. Load Snapshot
+    const migrationsDir = config.out;
+    const existingSnapshot = (await loadSnapshot(migrationsDir)) || { version: "0", tables: {} };
+
+    // 3. Compare
+    const currentSnapshot = generateSnapshot(schema);
+    const changes = compareSchema(schema, existingSnapshot);
+
+    if (changes.length === 0) {
+      outro("No changes detected.");
+      return;
+    }
+
+    console.log(`Detected ${changes.length} changes.`);
+
+    // 4. Generate Migration Script
+    const version = await getNextMigrationVersion(migrationsDir);
+
+    let name = options.name;
+    if (!name) {
+      name = (await text({
+        message: "Enter migration name",
+        placeholder: "init",
+        initialValue: "migration",
+        validate(value) {
+          if (value.length === 0) return "Name is required";
+        },
+      })) as string;
     }
+
+    if (isCancel(name)) {
+      cancel("Operation cancelled.");
+      return;
+    }
+
+    const filename = `${version}_${name}.ts`;
+    if (!existsSync(migrationsDir)) {
+      await mkdir(migrationsDir, { recursive: true });
+    }
+    const filePath = join(migrationsDir, filename);
+
+    const scriptContent = generateMigrationScript(changes);
+    await writeFile(filePath, scriptContent);
+    console.log(`Created migration: ${filename}`);
+
+    // 5. Save new Snapshot
+    await saveSnapshot(migrationsDir, currentSnapshot);
+    outro("Updated snapshot.json");
+  } catch (error) {
+    console.error("Error generating migration:", error);
+    process.exit(1);
+  }
 }
 
 function generateMigrationScript(changes: SchemaChange[]): string {
-    const upSteps: string[] = [];
-    const downSteps: string[] = [];
+  const upSteps: string[] = [];
+  const downSteps: string[] = [];
 
-    for (const change of changes) {
-        if (change.type === "create") {
-            upSteps.push(`// Create Table: ${change.table.TableName}`);
-            upSteps.push(`await db.createTable("${change.table.TableName}", ${JSON.stringify(change.table, null, 2)});
+  for (const change of changes) {
+    if (change.type === "create") {
+      upSteps.push(`// Create Table: ${change.table.TableName}`);
+      upSteps.push(`await db.createTable("${change.table.TableName}", ${JSON.stringify(change.table, null, 2)});
 `);
-            
-            downSteps.unshift(`// Drop Table: ${change.table.TableName}`);
-            downSteps.unshift(`await db.deleteTable("${change.table.TableName}");
+
+      downSteps.unshift(`// Drop Table: ${change.table.TableName}`);
+      downSteps.unshift(`await db.deleteTable("${change.table.TableName}");
 `);
-        } else if (change.type === "delete") {
-            upSteps.push(`// Drop Table: ${change.tableName}`);
-            upSteps.push(`await db.deleteTable("${change.tableName}");
+    } else if (change.type === "delete") {
+      upSteps.push(`// Drop Table: ${change.tableName}`);
+      upSteps.push(`await db.deleteTable("${change.tableName}");
 `);
-            
-            downSteps.unshift(`// Create Table: ${change.tableName}`);
-            downSteps.unshift(`// TODO: Restore table definition for rollback
+
+      downSteps.unshift(`// Create Table: ${change.tableName}`);
+      downSteps.unshift(`// TODO: Restore table definition for rollback
 `);
-        } else if (change.type === "update") {
-            upSteps.push(`// Update Table: ${change.tableName}`);
-            downSteps.unshift(`// Revert Update Table: ${change.tableName}`);
-        }
+    } else if (change.type === "update") {
+      upSteps.push(`// Update Table: ${change.tableName}`);
+      downSteps.unshift(`// Revert Update Table: ${change.tableName}`);
     }
+  }
 
-    return `import { Mizzle } from "@aurios/mizzle";
+  return `import { Mizzle } from "@aurios/mizzle";
 
 export async function up(db: Mizzle) {
     ${upSteps.join("    ")}

package/src/commands/init.ts

@@ -67,7 +67,7 @@ export default defineConfig({
   schema: "${schema}",
   out: "${out}",
   region: "${region}",
-  ${endpoint ? `endpoint: "${endpoint}",` : "// endpoint: \"http://localhost:8000\","}
+  ${endpoint ? `endpoint: "${endpoint}",` : '// endpoint: "http://localhost:8000",'}
 });
 `;
 

package/src/commands/list.ts

@@ -4,45 +4,47 @@ import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
 import { intro, outro, spinner } from "@clack/prompts";
 
 interface ListOptions {
-    config: MizzleConfig;
-    client?: DynamoDBClient;
+  config: MizzleConfig;
+  client?: DynamoDBClient;
 }
 
 export async function listCommand(options: ListOptions) {
-    intro("Mizzle List Tables");
-    
-    const client = options.client || getClient(options.config);
-    const s = spinner();
-    s.start("Fetching remote tables...");
-
-    try {
-        const snapshot = await getRemoteSnapshot(client);
-        s.stop("Fetched remote tables.");
-        
-        const tables = Object.values(snapshot.tables);
-
-        if (tables.length === 0) {
-            console.log("No tables found in the remote environment.");
-            outro("Done");
-            return;
-        }
-
-        console.log(`Found ${tables.length} tables:`);
-        for (const table of tables) {
-            console.log(`- ${table.TableName}`);
-            const pk = table.KeySchema.find(k => k.KeyType === "HASH")?.AttributeName;
-            const sk = table.KeySchema.find(k => k.KeyType === "RANGE")?.AttributeName;
-            console.log(`  PK: ${pk}, SK: ${sk || "(none)"}`);
-            
-            if (table.GlobalSecondaryIndexes && table.GlobalSecondaryIndexes.length > 0) {
-                 console.log(`  GSIs: ${table.GlobalSecondaryIndexes.map(g => g.IndexName).join(", ")}`);
-            }
-        }
-
-        outro("Done");
-    } catch (error) {
-        s.stop("Failed to fetch tables.");
-        console.error("Error listing tables:", error);
-        process.exit(1);
+  intro("Mizzle List Tables");
+
+  const client = options.client || getClient(options.config);
+  const s = spinner();
+  s.start("Fetching remote tables...");
+
+  try {
+    const snapshot = await getRemoteSnapshot(client);
+    s.stop("Fetched remote tables.");
+
+    const tables = Object.values(snapshot.tables);
+
+    if (tables.length === 0) {
+      console.log("No tables found in the remote environment.");
+      outro("Done");
+      return;
     }
+
+    console.log(`Found ${tables.length} tables:`);
+    for (const table of tables) {
+      console.log(`- ${table.TableName}`);
+      const pk = table.KeySchema.find((k: any) => k.KeyType === "HASH")?.AttributeName;
+      const sk = table.KeySchema.find((k: any) => k.KeyType === "RANGE")?.AttributeName;
+      console.log(`  PK: ${pk}, SK: ${sk || "(none)"}`);
+
+      if (table.GlobalSecondaryIndexes && table.GlobalSecondaryIndexes.length > 0) {
+        console.log(
+          `  GSIs: ${table.GlobalSecondaryIndexes.map((g: any) => g.IndexName).join(", ")}`,
+        );
+      }
+    }
+
+    outro("Done");
+  } catch (error) {
+    s.stop("Failed to fetch tables.");
+    console.error("Error listing tables:", error);
+    process.exit(1);
+  }
 }

package/src/commands/push.ts

@@ -6,70 +6,70 @@ import { DynamoDBClient, CreateTableCommand } from "@aws-sdk/client-dynamodb";
 import { confirm, isCancel, cancel, intro, outro, spinner } from "@clack/prompts";
 
 interface PushOptions {
-    config: MizzleConfig;
-    force?: boolean;
-    discoverSchema?: typeof discoverSchema;
-    client?: DynamoDBClient;
+  config: MizzleConfig;
+  force?: boolean;
+  discoverSchema?: typeof discoverSchema;
+  client?: DynamoDBClient;
 }
 
 export async function pushCommand(options: PushOptions) {
-    intro("Mizzle Push");
-    const { config, force } = options;
-    const discover = options.discoverSchema || discoverSchema;
-    
-    const client = options.client || getClient(config); 
+  intro("Mizzle Push");
+  const { config, force } = options;
+  const discover = options.discoverSchema || discoverSchema;
 
-    try {
-        const schema = await discover(config);
-        const remoteSnapshot = await getRemoteSnapshot(client);
+  const client = options.client || getClient(config);
 
-        const changes = compareSchema(schema, remoteSnapshot);
+  try {
+    const schema = await discover(config);
+    const remoteSnapshot = await getRemoteSnapshot(client);
 
-        if (changes.length === 0) {
-            outro("Remote is up to date.");
-            return;
-        }
+    const changes = compareSchema(schema, remoteSnapshot);
 
-        console.log(`Pushing ${changes.length} changes to remote...`);
+    if (changes.length === 0) {
+      outro("Remote is up to date.");
+      return;
+    }
+
+    console.log(`Pushing ${changes.length} changes to remote...`);
 
-        let shouldContinue = force;
-        if (!shouldContinue) {
-            shouldContinue = await confirm({
-                message: "Do you want to apply these changes?"
-            }) as boolean;
-        }
+    let shouldContinue = force;
+    if (!shouldContinue) {
+      shouldContinue = (await confirm({
+        message: "Do you want to apply these changes?",
+      })) as boolean;
+    }
 
-        if (isCancel(shouldContinue) || !shouldContinue) {
-            cancel("Operation cancelled.");
-            return;
-        }
+    if (isCancel(shouldContinue) || !shouldContinue) {
+      cancel("Operation cancelled.");
+      return;
+    }
 
-        const s = spinner();
-        s.start("Pushing changes...");
+    const s = spinner();
+    s.start("Pushing changes...");
 
-        for (const change of changes) {
-            if (change.type === "create") {
-                s.message(`Creating table: ${change.table.TableName}`);
-                await client.send(
-                    new CreateTableCommand({
-                        TableName: change.table.TableName,
-                        AttributeDefinitions: change.table.AttributeDefinitions,
-                        KeySchema: change.table.KeySchema,
-                        GlobalSecondaryIndexes: change.table.GlobalSecondaryIndexes,
-                        LocalSecondaryIndexes: change.table.LocalSecondaryIndexes,
-                        BillingMode: "PAY_PER_REQUEST",
-                    }),
-                );
-            } else if (change.type === "delete") {
-                console.log(`Untracked table found: ${change.tableName} (Skipping deletion)`);
-            } else if (change.type === "update") {
-                s.message(`Updating table: ${change.tableName} (Not fully implemented)`);
-            }
-        }
-        s.stop("Push complete.");
-        outro("Done");
-    } catch (error) {
-        console.error("Error pushing changes:", error);
-        process.exit(1);
+    for (const change of changes) {
+      if (change.type === "create") {
+        s.message(`Creating table: ${change.table.TableName}`);
+        await client.send(
+          new CreateTableCommand({
+            TableName: change.table.TableName,
+            AttributeDefinitions: change.table.AttributeDefinitions,
+            KeySchema: change.table.KeySchema,
+            GlobalSecondaryIndexes: change.table.GlobalSecondaryIndexes,
+            LocalSecondaryIndexes: change.table.LocalSecondaryIndexes,
+            BillingMode: "PAY_PER_REQUEST",
+          }),
+        );
+      } else if (change.type === "delete") {
+        console.log(`Untracked table found: ${change.tableName} (Skipping deletion)`);
+      } else if (change.type === "update") {
+        s.message(`Updating table: ${change.tableName} (Not fully implemented)`);
+      }
     }
+    s.stop("Push complete.");
+    outro("Done");
+  } catch (error) {
+    console.error("Error pushing changes:", error);
+    process.exit(1);
+  }
 }

package/src/config.ts

@@ -66,20 +66,20 @@ export interface MizzleConfig {
 
 /**
  * Helper function to define the Mizzle CLI configuration with type safety and autocompletion.
- * 
+ *
  * Typically used in a `mizzle.config.ts` file at the root of your project.
- * 
+ *
  * @example
  * ```ts
  * import { defineConfig } from "@aurios/mizzling";
- * 
+ *
  * export default defineConfig({
  *   schema: "./src/schema.ts",
  *   out: "./mizzle",
  *   region: "us-east-1",
  * });
  * ```
- * 
+ *
  * @param config The Mizzle configuration object.
  * @returns The same configuration object, validated by TypeScript.
  */
@@ -89,20 +89,20 @@ export function defineConfig(config: MizzleConfig): MizzleConfig {
 
 /**
  * Creates a configured DynamoDBClient instance based on the provided configuration.
- * 
+ *
  * It prioritizes credentials in the following order:
  * 1. Explicitly provided `credentials` object.
  * 2. Explicitly provided AWS `profile`.
  * 3. Default "local" credentials if the endpoint is localhost/127.0.0.1.
  * 4. Default AWS SDK credential provider chain (environment variables, IAM roles, etc.).
- * 
+ *
  * @param config The Mizzle configuration.
  * @returns A configured DynamoDBClient instance.
  */
 export function getClient(config: MizzleConfig): DynamoDBClient {
   const agentOptions = {
-      keepAlive: true,
-      maxSockets: Infinity,
+    keepAlive: true,
+    maxSockets: Infinity,
   };
 
   const clientConfig: DynamoDBClientConfig = {
@@ -110,8 +110,8 @@ export function getClient(config: MizzleConfig): DynamoDBClient {
     endpoint: config.endpoint,
     maxAttempts: config.maxAttempts,
     requestHandler: new NodeHttpHandler({
-        httpAgent: new http.Agent(agentOptions),
-        httpsAgent: new https.Agent(agentOptions),
+      httpAgent: new http.Agent(agentOptions),
+      httpsAgent: new https.Agent(agentOptions),
     }),
   };
 
@@ -134,10 +134,10 @@ export function getClient(config: MizzleConfig): DynamoDBClient {
 
 /**
  * Loads the Mizzle configuration from a file (defaulting to mizzle.config.ts).
- * 
+ *
  * Environment variables (MIZZLE_REGION, MIZZLE_ENDPOINT, MIZZLE_SCHEMA, MIZZLE_OUT)
  * will override values provided in the configuration file.
- * 
+ *
  * @param configName The name of the config file to load.
  * @returns A promise that resolves to the loaded and overridden configuration.
  * @throws Error if the configuration file is missing or invalid.
@@ -155,7 +155,7 @@ export async function loadConfig(configName = "mizzle.config.ts"): Promise<Mizzl
     const config = imported.default || imported;
 
     if (!config || typeof config !== "object") {
-       throw new Error("Invalid config: default export must be an object");
+      throw new Error("Invalid config: default export must be an object");
     }
 
     if (!config.schema) {
@@ -178,7 +178,7 @@ export async function loadConfig(configName = "mizzle.config.ts"): Promise<Mizzl
     return finalConfig;
   } catch (error) {
     if (error instanceof Error && error.message.startsWith("Invalid config")) {
-        throw error;
+      throw error;
     }
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to load config: ${message}`);

package/src/discovery.ts

@@ -1,11 +1,13 @@
 import { type MizzleConfig } from "./config";
 import { PhysicalTable, Entity } from "@aurios/mizzle/table";
-import { TABLE_SYMBOLS, ENTITY_SYMBOLS } from "@mizzle/shared";
+import { TABLE_SYMBOLS, ENTITY_SYMBOLS } from "@repo/shared";
 import fg from "fast-glob";
 import { stat } from "fs/promises";
 import { resolve } from "path";
 
-export async function discoverSchema(config: MizzleConfig): Promise<{ tables: PhysicalTable[], entities: Entity[] }> {
+export async function discoverSchema(
+  config: MizzleConfig,
+): Promise<{ tables: PhysicalTable[]; entities: Entity[] }> {
   const schemaPatterns = Array.isArray(config.schema) ? config.schema : [config.schema];
   const tables: PhysicalTable[] = [];
   const entities: Entity[] = [];
@@ -15,47 +17,53 @@ export async function discoverSchema(config: MizzleConfig): Promise<{ tables: Ph
     const absolutePath = resolve(process.cwd(), file);
     if (scannedFiles.has(absolutePath)) return;
     scannedFiles.add(absolutePath);
-    
+
     try {
-        const imported = await import(absolutePath);
-        for (const key in imported) {
-            const exportVal = imported[key];
-            if (!exportVal || typeof exportVal !== "object") continue;
-
-            if (exportVal instanceof PhysicalTable || exportVal[TABLE_SYMBOLS.TABLE_NAME] !== undefined) {
-                tables.push(exportVal as PhysicalTable);
-            } else if (exportVal instanceof Entity || exportVal[ENTITY_SYMBOLS.ENTITY_NAME] !== undefined) {
-                entities.push(exportVal as Entity);
-            }
+      const imported = await import(absolutePath);
+      for (const key in imported) {
+        const exportVal = imported[key];
+        if (!exportVal || typeof exportVal !== "object") continue;
+
+        if (
+          exportVal instanceof PhysicalTable ||
+          exportVal[TABLE_SYMBOLS.TABLE_NAME] !== undefined
+        ) {
+          tables.push(exportVal as PhysicalTable);
+        } else if (
+          exportVal instanceof Entity ||
+          exportVal[ENTITY_SYMBOLS.ENTITY_NAME] !== undefined
+        ) {
+          entities.push(exportVal as Entity);
         }
+      }
     } catch (e) {
-        console.warn(`Failed to import schema file: ${absolutePath}`, e);
+      console.warn(`Failed to import schema file: ${absolutePath}`, e);
     }
   };
 
   for (const pattern of schemaPatterns) {
     let searchPattern = pattern;
     let isDirectFile = false;
-    
+
     try {
-        const stats = await stat(pattern);
-        if (stats.isDirectory()) {
-            searchPattern = `${pattern}/**/*.{ts,js,tsx,jsx}`;
-        } else if (stats.isFile()) {
-            isDirectFile = true;
-        }
+      const stats = await stat(pattern);
+      if (stats.isDirectory()) {
+        searchPattern = `${pattern}/**/*.{ts,js,tsx,jsx}`;
+      } else if (stats.isFile()) {
+        isDirectFile = true;
+      }
     } catch {
-        // Not a file/dir, assume it's a glob pattern
+      // Not a file/dir, assume it's a glob pattern
     }
 
     if (isDirectFile) {
-        await processFile(pattern);
-        continue;
+      await processFile(pattern);
+      continue;
     }
 
     const files = await fg(searchPattern, { absolute: true });
     for (const file of files) {
-        await processFile(file);
+      await processFile(file);
     }
   }