@aurios/mizzling 1.1.0 → 1.1.2

package/test/e2e.test.ts

@@ -0,0 +1,135 @@
+import { expect, test, describe, beforeAll, afterAll } from "vitest";
+import { spawn } from "child_process";
+import { mkdirSync, rmSync, existsSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { DynamoDBClient, DeleteTableCommand } from "@aws-sdk/client-dynamodb";
+
+const TEMP_DIR = join(tmpdir(), "mizzle-e2e-test-" + Date.now());
+const MIGRATIONS_DIR = join(TEMP_DIR, "migrations");
+const SCHEMA_FILE = join(TEMP_DIR, "schema.ts");
+const CONFIG_FILE = join(TEMP_DIR, "mizzle.config.ts");
+
+function runCommand(
+  args: string[],
+  env: Record<string, string>,
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  return new Promise((resolve) => {
+    const proc = spawn("bun", args, {
+      cwd: process.cwd(),
+      env: { ...process.env, ...env },
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    proc.stdout.on("data", (data) => (stdout += data.toString()));
+    proc.stderr.on("data", (data) => (stderr += data.toString()));
+
+    proc.on("close", (code) => {
+      resolve({ code: code || 0, stdout, stderr });
+    });
+  });
+}
+
+describe("CLI End-to-End Migration Lifecycle", () => {
+  const projectRoot = process.cwd().includes("packages/mizzling") 
+    ? join(process.cwd(), "../..") 
+    : process.cwd();
+  const mizzleTablePath = join(projectRoot, "packages/mizzle/src/core/table");
+  const mizzleColumnsPath = join(projectRoot, "packages/mizzle/src/columns/index");
+  const mizzleStrategiesPath = join(projectRoot, "packages/mizzle/src/core/strategies");
+  const mizzlingConfigPath = join(projectRoot, "packages/mizzling/src/config");
+  const mizzlingCliPath = join(projectRoot, "packages/mizzling/src/cli.ts");
+
+  beforeAll(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+
+    // Create a simple schema
+    writeFileSync(
+      SCHEMA_FILE,
+      `
+import { dynamoTable, dynamoEntity } from "${mizzleTablePath}";
+import { string } from "${mizzleColumnsPath}";
+import { staticKey } from "${mizzleStrategiesPath}";
+
+export const testTable = dynamoTable("e2e_test_table", {
+    pk: string("pk"),
+});
+
+export const testEntity = dynamoEntity(testTable, "Test", { name: string() }, (cols) => ({
+    pk: staticKey("FIXED"),
+}));
+        `.trim(),
+    );
+
+    // Create config
+    writeFileSync(
+      CONFIG_FILE,
+      `
+import { defineConfig } from "${mizzlingConfigPath}";
+export default defineConfig({
+    schema: "${SCHEMA_FILE}",
+    out: "${MIGRATIONS_DIR}",
+    region: "us-east-1",
+    endpoint: "http://localhost:8000"
+});
+        `.trim(),
+    );
+  });
+
+  afterAll(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("Full lifecycle: generate -> push -> list -> drop", async () => {
+    // 1. Generate
+    const {
+      code: generateExit,
+      stdout: genStdout,
+      stderr: genStderr,
+    } = await runCommand([mizzlingCliPath, "generate", "--name", "initial"], {
+      MIZZLE_CONFIG: CONFIG_FILE,
+    });
+
+    if (generateExit !== 0 || !existsSync(MIGRATIONS_DIR)) {
+      console.error("Generate failed or migrations dir missing!");
+      console.error("STDOUT:", genStdout);
+      console.error("STDERR:", genStderr);
+    }
+    expect(generateExit).toBe(0);
+    expect(existsSync(MIGRATIONS_DIR)).toBe(true);
+    expect(readdirSync(MIGRATIONS_DIR).some((f) => f.endsWith("_initial.ts"))).toBe(true);
+
+    // 2. Push
+    const {
+      code: pushExit,
+      stdout: pushStdout,
+      stderr: pushStderr,
+    } = await runCommand([mizzlingCliPath, "push", "--yes"], {
+      MIZZLE_CONFIG: CONFIG_FILE,
+    });
+
+    if (pushExit !== 0) {
+      console.error("Push failed!");
+      console.error("STDOUT:", pushStdout);
+      console.error("STDERR:", pushStderr);
+    }
+    expect(pushExit).toBe(0);
+
+    // 3. List
+    const { stdout: listOutput } = await runCommand([mizzlingCliPath, "list"], {
+      MIZZLE_CONFIG: CONFIG_FILE,
+    });
+
+    expect(listOutput).toContain("e2e_test_table");
+
+    // 4. Cleanup: Drop the table manually to leave clean state
+    const client = new DynamoDBClient({
+      region: "us-east-1",
+      endpoint: "http://localhost:8000",
+      credentials: { accessKeyId: "local", secretAccessKey: "local" },
+    });
+    await client.send(new DeleteTableCommand({ TableName: "e2e_test_table" }));
+  }, 20000); // Higher timeout for spawning
+});

package/test/generate.test.ts

@@ -0,0 +1,116 @@
+import { expect, test, describe, beforeEach, afterEach, vi } from "vitest";
+import { generateCommand } from "../src/commands/generate";
+import { PhysicalTable } from "@aurios/mizzle/table";
+import { TABLE_SYMBOLS } from "@repo/shared";
+import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// Mock Clack
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  text: vi.fn(() => Promise.resolve("migration")),
+  isCancel: vi.fn(() => false),
+  cancel: vi.fn(),
+}));
+
+// Helper to create mock table
+const mockTable = (name: string) => {
+  const table = new PhysicalTable(name, {
+    pk: {
+      build: () => ({
+        _: { name: "id", type: "string" },
+        getDynamoType: () => "S",
+        name: "id",
+      }),
+    } as any,
+  });
+  table[TABLE_SYMBOLS.TABLE_NAME] = name;
+  table[TABLE_SYMBOLS.PARTITION_KEY] = {
+    name: "id",
+    getDynamoType: () => "S",
+  } as any;
+  return table;
+};
+
+const TEMP_DIR = join(tmpdir(), "mizzle-generate-test-" + Date.now());
+const MIGRATIONS_DIR = join(TEMP_DIR, "migrations");
+const SCHEMA_FILE = join(TEMP_DIR, "schema.ts");
+
+describe("Generate Command", () => {
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+    mkdirSync(MIGRATIONS_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  // Mock discoverSchema to return our tables
+  const mockDiscover = vi.fn();
+
+  test("should create initial snapshot and migration if none exist", async () => {
+    // Setup
+    const tables = [mockTable("users")];
+    mockDiscover.mockResolvedValue({ tables, entities: [] });
+
+    await generateCommand({
+      config: { schema: SCHEMA_FILE, out: MIGRATIONS_DIR },
+      discoverSchema: mockDiscover, // Dependency injection for testing
+    });
+
+    // Verify Snapshot
+    const snapshotPath = join(MIGRATIONS_DIR, "snapshot.json");
+    expect(existsSync(snapshotPath)).toBe(true);
+    const snapshot = JSON.parse(readFileSync(snapshotPath, "utf-8"));
+    expect(snapshot.tables["users"]).toBeDefined();
+
+    // Verify Migration Script
+    const files = await import("fs").then((fs) => fs.readdirSync(MIGRATIONS_DIR));
+    const migrationFile = files.find((f) => f.endsWith(".ts"));
+    expect(migrationFile).toBeDefined();
+    expect(migrationFile).toMatch(/^0000_.*\.ts$/);
+  });
+
+  test("should not create migration if no changes", async () => {
+    // Setup: Create snapshot first
+    const tables = [mockTable("users")];
+    mockDiscover.mockResolvedValue({ tables, entities: [] });
+
+    // Run once to setup
+    await generateCommand({
+      config: { schema: SCHEMA_FILE, out: MIGRATIONS_DIR },
+      discoverSchema: mockDiscover,
+    });
+
+    const filesBefore = await import("fs").then((fs) => fs.readdirSync(MIGRATIONS_DIR));
+
+    // Run again
+    await generateCommand({
+      config: { schema: SCHEMA_FILE, out: MIGRATIONS_DIR },
+      discoverSchema: mockDiscover,
+    });
+
+    const filesAfter = await import("fs").then((fs) => fs.readdirSync(MIGRATIONS_DIR));
+    expect(filesAfter.length).toBe(filesBefore.length);
+  });
+
+  test("should handle errors gracefully", async () => {
+    mockDiscover.mockRejectedValue(new Error("Discovery failed"));
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const processExitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+
+    await generateCommand({
+      config: { schema: SCHEMA_FILE, out: MIGRATIONS_DIR },
+      discoverSchema: mockDiscover,
+    });
+
+    expect(errorSpy).toHaveBeenCalled();
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    errorSpy.mockRestore();
+    processExitSpy.mockRestore();
+  });
+});

package/test/init-command.test.ts

@@ -0,0 +1,78 @@
+import { expect, test, describe, beforeEach, afterEach, vi } from "vitest";
+import { initCommand } from "../src/commands/init";
+import { writeFileSync, existsSync, rmSync, mkdirSync, readFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import * as prompts from "@clack/prompts";
+
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  text: vi.fn(),
+  isCancel: vi.fn((val) => typeof val === "symbol" && val.toString().includes("clack:cancel")),
+  note: vi.fn(),
+  cancel: vi.fn(),
+}));
+
+const TEMP_DIR = join(tmpdir(), "mizzle-init-test-" + Date.now());
+
+describe("Init Command", () => {
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+    process.chdir(TEMP_DIR);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should create mizzle.config.ts with user input", async () => {
+    // Mock prompts
+    (prompts.text as unknown as { mockImplementation: (fn: unknown) => void }).mockImplementation(
+      async (options: { message: string; initialValue?: string }) => {
+        const message = options.message;
+        if (message.includes("schema")) return "./src/schema.ts";
+        if (message.includes("output")) return "./migrations";
+        if (message.includes("region")) return "us-east-1";
+        if (message.includes("endpoint")) return "http://localhost:8000";
+        return options.initialValue || "";
+      },
+    );
+
+    await initCommand();
+
+    expect(existsSync(join(TEMP_DIR, "mizzle.config.ts"))).toBe(true);
+    const content = readFileSync(join(TEMP_DIR, "mizzle.config.ts"), "utf-8");
+    expect(content).toContain('schema: "./src/schema.ts"');
+    expect(content).toContain('out: "./migrations"');
+    expect(content).toContain('region: "us-east-1"');
+    expect(content).toContain('endpoint: "http://localhost:8000"');
+  });
+
+  test("should abort if mizzle.config.ts already exists", async () => {
+    writeFileSync(join(TEMP_DIR, "mizzle.config.ts"), "existing");
+    const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+    await initCommand();
+
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("already exists"));
+  });
+
+  test("should abort if user cancels", async () => {
+    const CANCEL = Symbol.for("clack:cancel");
+    (prompts.text as unknown as { mockResolvedValue: (val: unknown) => void }).mockResolvedValue(
+      CANCEL,
+    );
+    (prompts.isCancel as unknown as { mockReturnValue: (val: unknown) => void }).mockReturnValue(
+      true,
+    );
+
+    await initCommand();
+
+    expect(existsSync(join(TEMP_DIR, "mizzle.config.ts"))).toBe(false);
+  });
+});

package/test/init.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { spawnSync } from "child_process";
+import { join } from "path";
+
+test("cli should show help message", () => {
+  const projectRoot = process.cwd().includes("packages/mizzling") 
+    ? join(process.cwd(), "../..") 
+    : process.cwd();
+  const mizzlingCliPath = join(projectRoot, "packages/mizzling/src/cli.ts");
+
+  const result = spawnSync("bun", [mizzlingCliPath, "--help"], {
+    encoding: "utf-8",
+  });
+
+  // Since src/cli.ts doesn't exist, it might fail with a non-zero exit code or error
+  expect(result.status).toBe(0);
+  expect(result.stdout).toContain("Usage: mizzle [options] [command]");
+  expect(result.stdout).toContain("generate");
+  expect(result.stdout).toContain("push");
+  expect(result.stdout).toContain("list");
+  expect(result.stdout).toContain("drop");
+});

package/test/interactive.test.ts

@@ -0,0 +1,96 @@
+import { expect, test, describe, beforeEach, afterEach, vi } from "vitest";
+import { generateCommand } from "../src/commands/generate";
+import { pushCommand } from "../src/commands/push";
+import { PhysicalTable } from "@aurios/mizzle/table";
+import { TABLE_SYMBOLS } from "@repo/shared";
+import { mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// Mocks
+const { mockClack } = vi.hoisted(() => ({
+  mockClack: {
+    text: vi.fn(() => Promise.resolve("test_migration")),
+    confirm: vi.fn(() => Promise.resolve(true)),
+    intro: vi.fn(() => {}),
+    outro: vi.fn(() => {}),
+    spinner: vi.fn(() => ({ start: vi.fn(), stop: vi.fn(), message: vi.fn() })),
+    isCancel: vi.fn(() => false),
+  },
+}));
+
+vi.mock("@clack/prompts", () => ({
+  text: mockClack.text,
+  confirm: mockClack.confirm,
+  intro: mockClack.intro,
+  outro: mockClack.outro,
+  spinner: mockClack.spinner,
+  isCancel: mockClack.isCancel,
+}));
+
+const mockTable = (name: string) => {
+  const table = new PhysicalTable(name, {
+    pk: {
+      build: () => ({
+        _: { name: "id", type: "string" },
+        getDynamoType: () => "S",
+        name: "id",
+      }),
+    } as any,
+  });
+  table[TABLE_SYMBOLS.TABLE_NAME] = name;
+  table[TABLE_SYMBOLS.PARTITION_KEY] = {
+    name: "id",
+    getDynamoType: () => "S",
+  } as any;
+  return table;
+};
+
+// Mock Client
+const createMockClient = () => {
+  return {
+    send: async () => ({ TableNames: [], Table: undefined }),
+  } as unknown;
+};
+
+const TEMP_DIR = join(tmpdir(), "mizzle-interactive-test-" + Date.now());
+
+describe("Interactive Commands", () => {
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+    vi.mocked(mockClack.text).mockClear();
+    vi.mocked(mockClack.confirm).mockClear();
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  const mockDiscover = vi.fn();
+
+  test("generateCommand should ask for migration name", async () => {
+    const tables = [mockTable("users")];
+    mockDiscover.mockResolvedValue({ tables, entities: [] });
+
+    await generateCommand({
+      config: { schema: "dummy", out: TEMP_DIR } as any,
+      discoverSchema: mockDiscover,
+    });
+
+    expect(mockClack.text).toHaveBeenCalled();
+  });
+
+  test("pushCommand should ask for confirmation", async () => {
+    const tables = [mockTable("users")];
+    mockDiscover.mockResolvedValue({ tables, entities: [] });
+    const client = createMockClient();
+
+    await pushCommand({
+      config: { schema: "dummy", out: TEMP_DIR } as any,
+      discoverSchema: mockDiscover,
+      client: client as any,
+    });
+
+    expect(mockClack.confirm).toHaveBeenCalled();
+  });
+});

package/test/list.test.ts

@@ -0,0 +1,58 @@
+import { expect, test, describe, beforeEach, vi } from "vitest";
+import { listCommand } from "../src/commands/list";
+import type { IMizzleClient } from "../../mizzle/src/core/client";
+
+// Mock Console
+const logSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+
+// Manual Mock Client
+const createMockClient = (tables: Record<string, unknown>[]) => {
+  return {
+    send: async (command: { constructor: { name: string }; input?: { TableName: string } }) => {
+      const cmdName = command.constructor.name;
+      if (cmdName === "ListTablesCommand") {
+        return { TableNames: tables.map((t) => t.TableName as string) };
+      }
+      if (cmdName === "DescribeTableCommand") {
+        const tableName = command.input?.TableName;
+        const table = tables.find((t) => t.TableName === tableName);
+        return { Table: table };
+      }
+      return {};
+    },
+  };
+};
+
+describe("List Command", () => {
+  beforeEach(() => {
+    logSpy.mockClear();
+  });
+
+  test("should list remote tables", async () => {
+    const mockTables = [
+      {
+        TableName: "users",
+        AttributeDefinitions: [{ AttributeName: "id", AttributeType: "S" }],
+        KeySchema: [{ AttributeName: "id", KeyType: "HASH" }],
+      },
+    ];
+    const client = createMockClient(mockTables) as unknown;
+
+    await listCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      client: client as any,
+    });
+
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("users"));
+    // Basic check for now
+  });
+
+  test("should handle empty list", async () => {
+    const client = createMockClient([]) as unknown;
+    await listCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      client: client as any,
+    });
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("No tables found"));
+  });
+});

package/test/mizzling-exports.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { defineConfig } from "@aurios/mizzling/index";
+
+describe("Mizzling Package Exports", () => {
+  it("should export defineConfig", () => {
+    expect(defineConfig).toBeDefined();
+    expect(typeof defineConfig).toBe("function");
+  });
+
+  it("should return config object as is", () => {
+    const config = {
+      schema: "./schema",
+      out: "./migrations",
+    };
+    const result = defineConfig(config);
+    expect(result).toBe(config);
+  });
+});

package/test/push.test.ts

@@ -0,0 +1,88 @@
+import { expect, test, describe, vi } from "vitest";
+import { pushCommand } from "../src/commands/push";
+import { PhysicalTable } from "@aurios/mizzle/table";
+import { TABLE_SYMBOLS } from "@repo/shared";
+import type { IMizzleClient } from "../../mizzle/src/core/client";
+
+// Mock Clack
+vi.mock("@clack/prompts", () => ({
+  text: vi.fn(() => Promise.resolve("migration")),
+  confirm: vi.fn(() => Promise.resolve(true)),
+  intro: vi.fn(() => {}),
+  outro: vi.fn(() => {}),
+  spinner: () => ({ start: () => {}, stop: () => {}, message: () => {} }),
+  isCancel: () => false,
+}));
+
+// Mock Table
+const mockTable = (name: string) => {
+  const table = new PhysicalTable(name, {
+    pk: {
+      build: () => ({
+        _: { name: "id", type: "string" },
+        getDynamoType: () => "S",
+        name: "id",
+      }),
+    } as any,
+  });
+  table[TABLE_SYMBOLS.TABLE_NAME] = name;
+  table[TABLE_SYMBOLS.PARTITION_KEY] = {
+    name: "id",
+    getDynamoType: () => "S",
+  } as any;
+  return table;
+};
+
+// Manual Mock Client
+const createMockClient = () => {
+  const sends: unknown[] = [];
+  return {
+    send: async (command: { constructor: { name: string }; input: Record<string, unknown> }) => {
+      sends.push(command);
+      const cmdName = command.constructor.name;
+
+      if (cmdName === "ListTablesCommand") {
+        return { TableNames: [] };
+      }
+      if (cmdName === "CreateTableCommand") {
+        return {};
+      }
+      return {};
+    },
+    // Helper to access captured calls
+    _sends: sends,
+  };
+};
+
+describe("Push Command", () => {
+  const mockDiscover = vi.fn();
+
+  test("should create table if it does not exist in remote", async () => {
+    // Setup
+    const tables = [mockTable("users")];
+    mockDiscover.mockResolvedValue({ tables, entities: [] });
+
+    const mockClient = createMockClient() as unknown;
+
+    await pushCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      discoverSchema: mockDiscover,
+      client: mockClient as any,
+    });
+
+    // Verify CreateTable was called
+    // We look for CreateTableCommand in mockClient._sends
+    const createCall = (
+      mockClient as {
+        _sends: {
+          constructor: { name: string };
+          input: { TableName: string; KeySchema: unknown };
+        }[];
+      }
+    )._sends.find((cmd) => cmd.constructor.name === "CreateTableCommand");
+
+    expect(createCall).toBeDefined();
+    expect(createCall!.input.TableName).toBe("users");
+    expect(createCall!.input.KeySchema).toBeDefined();
+  });
+});

package/tsconfig.json

@@ -1,13 +1,35 @@
 {
-  "extends": "@mizzle/tsconfig/base.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "baseUrl": ".",
-    "paths": {
-      "@mizzle/shared": ["../shared/src/index.ts"],
-      "mizzle": ["../mizzle/src/index.ts"],
-      "mizzle/*": ["../mizzle/src/*"]
-    }
-  },
-  "include": ["src"]
+    "extends": "@repo/typescript-config/base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "paths": {
+            "@repo/shared": [
+                "./../shared/src/index.ts"
+            ],
+            "@aurios/mizzle": [
+                "./../mizzle/src/index.ts"
+            ],
+            "@aurios/mizzle/columns": [
+                "./../mizzle/src/columns/index.ts"
+            ],
+            "@aurios/mizzle/table": [
+                "./../mizzle/src/core/table.ts"
+            ],
+            "@aurios/mizzle/snapshot": [
+                "./../mizzle/src/core/snapshot.ts"
+            ],
+            "@aurios/mizzle/diff": [
+                "./../mizzle/src/core/diff.ts"
+            ],
+            "@aurios/mizzle/introspection": [
+                "./../mizzle/src/core/introspection.ts"
+            ],
+            "@aurios/mizzle/db": [
+                "./../mizzle/src/db.ts"
+            ],
+            "@aurios/mizzle/*": [
+                "./../mizzle/src/*"
+            ]
+        }
+    },
 }

package/tsup.config.ts

@@ -1,12 +1,12 @@
-import { defineConfig } from 'tsup';
+import { defineConfig } from "tsup";
 
 export default defineConfig({
-  entry: ['src/cli.ts', 'src/index.ts'],
-  format: ['esm'],
+  entry: ["src/cli.ts", "src/index.ts"],
+  format: ["esm"],
   clean: true,
-  noExternal: ['@mizzle/shared', 'mizzle'],
+  noExternal: ["@repo/shared", "mizzle"],
   minify: true,
   banner: {
-    js: '#!/usr/bin/env node',
+    js: "#!/usr/bin/env node",
   },
 });