@aurios/mizzling 1.1.0 → 1.1.2

package/test/config-expansion.test.ts

@@ -0,0 +1,164 @@
+import { expect, test, describe, beforeEach, afterEach, vi } from "vitest";
+import { loadConfig, defineConfig, getClient } from "../src/config";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import * as credentialProviders from "@aws-sdk/credential-provider-ini";
+
+vi.mock("@aws-sdk/credential-provider-ini", () => ({
+    fromIni: vi.fn(),
+}));
+
+const TEMP_DIR = join(tmpdir(), "mizzle-config-expansion-test-" + Date.now());
+
+describe("Config Expansion", () => {
+    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("defineConfig should accept expanded properties", () => {
+        const config = defineConfig({
+            schema: "./schema.ts",
+            out: "./out",
+            profile: "test",
+            maxAttempts: 3,
+        });
+        expect(config.profile).toBe("test");
+        expect(config.maxAttempts).toBe(3);
+    });
+
+    test("should load config with expanded properties", async () => {
+        const configName = "mizzle.config.expanded.ts";
+        const configContent = `
+      export default {
+        schema: "./src/schema",
+        out: "./migrations",
+        credentials: {
+          accessKeyId: "AKIA",
+          secretAccessKey: "SECRET",
+          sessionToken: "TOKEN"
+        },
+        profile: "my-profile",
+        maxAttempts: 5
+      };
+    `;
+        writeFileSync(join(TEMP_DIR, configName), configContent);
+
+        const config = await loadConfig(configName);
+        expect(config).toEqual({
+            schema: "./src/schema",
+            out: "./migrations",
+            credentials: {
+                accessKeyId: "AKIA",
+                secretAccessKey: "SECRET",
+                sessionToken: "TOKEN",
+            },
+            profile: "my-profile",
+            maxAttempts: 5,
+        });
+    });
+
+    test("getClient should use provided credentials", async () => {
+        const config = {
+            schema: "./schema.ts",
+            out: "./out",
+            region: "us-west-2",
+            credentials: {
+                accessKeyId: "test-key",
+                secretAccessKey: "test-secret",
+            },
+        };
+        const client = getClient(config);
+        const resolvedConfig = await client.config.credentials();
+        expect(resolvedConfig.accessKeyId).toBe("test-key");
+        expect(resolvedConfig.secretAccessKey).toBe("test-secret");
+        expect(await client.config.region()).toBe("us-west-2");
+    });
+
+    test("getClient should use default credentials if no credentials or profile provided", async () => {
+        const originalEnv = { ...process.env };
+        process.env.AWS_ACCESS_KEY_ID = "env-key";
+        process.env.AWS_SECRET_ACCESS_KEY = "env-secret";
+        process.env.AWS_REGION = "us-east-1";
+
+        try {
+            const config = {
+                schema: "./schema.ts",
+                out: "./out",
+            };
+            const client = getClient(config);
+            const resolvedConfig = await client.config.credentials();
+            expect(resolvedConfig.accessKeyId).toBe("env-key");
+        } finally {
+            process.env = originalEnv;
+        }
+    });
+
+    test("getClient should use local defaults if endpoint is localhost and no credentials provided", async () => {
+        const config = {
+            schema: "./schema.ts",
+            out: "./out",
+            endpoint: "http://localhost:8000",
+        };
+        const client = getClient(config);
+        const resolvedConfig = await client.config.credentials();
+        expect(resolvedConfig.accessKeyId).toBe("local");
+    });
+
+    test("getClient should use profile if provided", async () => {
+        const config = {
+            schema: "./schema.ts",
+            out: "./out",
+            profile: "my-profile",
+        };
+        getClient(config);
+        expect(credentialProviders.fromIni).toHaveBeenCalledWith({ profile: "my-profile" });
+    });
+
+    test("getClient should use maxAttempts if provided", async () => {
+        const config = {
+            schema: "./schema.ts",
+            out: "./out",
+            maxAttempts: 10,
+        };
+        const client = getClient(config);
+        expect(await client.config.maxAttempts()).toBe(10);
+    });
+
+    test("loadConfig should support environment variable overrides", async () => {
+        const originalEnv = { ...process.env };
+        process.env.MIZZLE_REGION = "us-east-1-env";
+        process.env.MIZZLE_ENDPOINT = "http://env:8000";
+        process.env.MIZZLE_SCHEMA = "./src/schema-env";
+        process.env.MIZZLE_OUT = "./migrations-env";
+
+        try {
+            const configName = "mizzle.config.env.ts";
+            const configContent = `
+        export default {
+          schema: "./src/schema",
+          out: "./migrations",
+          region: "us-west-2"
+        };
+      `;
+            writeFileSync(join(TEMP_DIR, configName), configContent);
+
+            const config = await loadConfig(configName);
+            expect(config.region).toBe("us-east-1-env");
+            expect(config.endpoint).toBe("http://env:8000");
+            expect(config.schema).toBe("./src/schema-env");
+            expect(config.out).toBe("./migrations-env");
+        } finally {
+            process.env = originalEnv;
+        }
+    });
+});

package/test/config.test.ts

@@ -0,0 +1,72 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import { loadConfig } from "../src/config";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const TEMP_DIR = join(tmpdir(), "mizzle-config-test-" + Date.now());
+
+describe("Config Loader", () => {
+  const originalCwd = process.cwd();
+
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+    process.chdir(TEMP_DIR);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should throw if config file is missing", async () => {
+    await expect(loadConfig("non-existent.ts")).rejects.toThrow();
+  });
+
+  test("should load valid config", async () => {
+    const configName = "mizzle.config.valid.ts";
+    const configContent = `
+      export default {
+        schema: "./src/schema",
+        out: "./migrations"
+      };
+    `;
+    writeFileSync(join(TEMP_DIR, configName), configContent);
+
+    const config = await loadConfig(configName);
+    expect(config).toEqual({
+      schema: "./src/schema",
+      out: "./migrations",
+    });
+  });
+
+  test("should throw if config is invalid (missing out)", async () => {
+    const configName = "mizzle.config.invalid.ts";
+    const configContent = `
+      export default {
+        schema: "./src/schema"
+      };
+    `;
+    writeFileSync(join(TEMP_DIR, configName), configContent);
+
+    await expect(loadConfig(configName)).rejects.toThrow("Invalid config");
+  });
+
+  test("should throw if config is invalid (not an object)", async () => {
+    const configName = "mizzle.config.notobject.ts";
+    writeFileSync(join(TEMP_DIR, configName), 'export default "string";');
+    await expect(loadConfig(configName)).rejects.toThrow("Invalid config");
+  });
+
+  test("should throw if config is invalid (missing schema)", async () => {
+    const configName = "mizzle.config.noschema.ts";
+    writeFileSync(join(TEMP_DIR, configName), 'export default { out: "./" };');
+    await expect(loadConfig(configName)).rejects.toThrow("Invalid config: missing 'schema'");
+  });
+
+  test("should throw if config has syntax error", async () => {
+    const configName = "mizzle.config.syntax.ts";
+    writeFileSync(join(TEMP_DIR, configName), "export default { schema: ");
+    await expect(loadConfig(configName)).rejects.toThrow("Failed to load config");
+  });
+});

package/test/define-config-integration.test.ts

@@ -0,0 +1,49 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import { loadConfig } from "../src/config";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join, resolve } from "path";
+import { tmpdir } from "os";
+
+const TEMP_DIR = join(tmpdir(), "mizzle-define-config-test-" + Date.now());
+
+describe("defineConfig Integration", () => {
+  const originalCwd = process.cwd();
+  const projectRoot = originalCwd.includes("packages/mizzling") 
+    ? join(originalCwd, "../..") 
+    : originalCwd;
+  const mizzlingPath = join(projectRoot, "packages/mizzling/src/index.ts");
+
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+    process.chdir(TEMP_DIR);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should load config using defineConfig helper", async () => {
+    const configName = "mizzle.config.ts";
+    // Using relative path to the source index.ts for the test to work without publishing
+    const configContent = `
+      import { defineConfig } from '${mizzlingPath}';
+      
+      export default defineConfig({
+        schema: "./src/schema",
+        out: "./migrations",
+        verbose: true,
+        strict: false
+      });
+    `;
+    writeFileSync(join(TEMP_DIR, configName), configContent);
+
+    const config = await loadConfig(configName);
+    expect(config).toEqual({
+      schema: "./src/schema",
+      out: "./migrations",
+      verbose: true,
+      strict: false,
+    });
+  });
+});

package/test/discovery.test.ts

@@ -0,0 +1,117 @@
+import { expect, test, describe, beforeEach, afterEach } from "vitest";
+import { discoverSchema } from "../src/discovery";
+import { PhysicalTable, Entity } from "@aurios/mizzle/table";
+import { writeFileSync, mkdirSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const TEMP_DIR = join(tmpdir(), "mizzle-discovery-test-" + Date.now());
+
+describe("Schema Discovery", () => {
+  const originalCwd = process.cwd();
+  // Robustly find project root
+  const projectRoot = originalCwd.includes("packages/mizzling") 
+    ? join(originalCwd, "../..") 
+    : originalCwd;
+  const mizzleCoreTablePath = join(projectRoot, "packages/mizzle/src/core/table");
+
+  beforeEach(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(TEMP_DIR, { recursive: true, force: true });
+  });
+
+  test("should discover tables in a file", async () => {
+    const schemaContent = `
+      import { dynamoTable } from "${mizzleCoreTablePath}";
+
+      export const UsersTable = dynamoTable("users", {
+        pk: { build: () => ({ _: { name: "id", type: "string" } }) }, // Mocking column builder
+      });
+    `;
+    writeFileSync(join(TEMP_DIR, "schema.ts"), schemaContent);
+
+    const result = await discoverSchema({
+      schema: join(TEMP_DIR, "schema.ts"),
+      out: "./migrations",
+    });
+
+    expect(result.tables).toHaveLength(1);
+    expect(result.tables[0]).toBeInstanceOf(PhysicalTable);
+    // @ts-expect-error test-internal
+    expect(result.tables[0][Symbol.for("mizzle:TableName")]).toBe("users");
+  });
+
+  test("should discover entities in a file", async () => {
+    const schemaContent = `
+      import { dynamoTable, dynamoEntity, Entity } from "${mizzleCoreTablePath}";
+
+      const UsersTable = dynamoTable("users", {
+        pk: { build: () => ({ _: { name: "id", type: "string" } }) },
+      });
+
+      export const UserEntity = dynamoEntity(UsersTable, "User", {
+         id: { build: () => ({ _: { name: "id", type: "string" } }), setName: () => {} } as any
+      });
+    `;
+    writeFileSync(join(TEMP_DIR, "entity.ts"), schemaContent);
+
+    const result = await discoverSchema({
+      schema: join(TEMP_DIR, "entity.ts"),
+      out: "./migrations",
+    });
+
+    expect(result.entities).toHaveLength(1);
+    expect(result.entities[0]).toBeInstanceOf(Entity);
+    // @ts-expect-error test-internal
+    expect(result.entities[0][Symbol.for("mizzle:EntityName")]).toBe("User");
+  });
+
+  test("should ignore non-table exports", async () => {
+    const schemaContent = `
+      export const SomethingElse = { foo: "bar" };
+    `;
+    writeFileSync(join(TEMP_DIR, "other.ts"), schemaContent);
+
+    const result = await discoverSchema({
+      schema: join(TEMP_DIR, "other.ts"),
+      out: "./migrations",
+    });
+
+    expect(result.tables).toHaveLength(0);
+    expect(result.entities).toHaveLength(0);
+  });
+
+  test("should discover tables in a directory", async () => {
+    const schemaContent = `
+      import { dynamoTable } from "${mizzleCoreTablePath}";
+      export const UsersTable = dynamoTable("users_dir", { pk: { build: () => ({ _: { name: "id", type: "string" } }) } });
+    `;
+    mkdirSync(join(TEMP_DIR, "tables"), { recursive: true });
+    writeFileSync(join(TEMP_DIR, "tables/users.ts"), schemaContent);
+
+    const result = await discoverSchema({
+      schema: join(TEMP_DIR, "tables"), // Directory path
+      out: "./migrations",
+    });
+
+    expect(result.tables).toHaveLength(1);
+    // @ts-expect-error test-internal
+    expect(result.tables[0][Symbol.for("mizzle:TableName")]).toBe("users_dir");
+  });
+
+  test("should handle import failures gracefully", async () => {
+    const schemaContent = `
+      export const UsersTable = dynamoTable("users", ...); // Syntax error
+    `;
+    writeFileSync(join(TEMP_DIR, "broken.ts"), schemaContent);
+
+    const result = await discoverSchema({
+      schema: join(TEMP_DIR, "broken.ts"),
+      out: "./migrations",
+    });
+    expect(result.tables).toHaveLength(0);
+  });
+});

package/test/drop.test.ts

@@ -0,0 +1,145 @@
+import { expect, test, describe, beforeEach, vi } from "vitest";
+import { dropCommand } from "../src/commands/drop";
+import * as prompts from "@clack/prompts";
+import type { IMizzleClient } from "../../mizzle/src/core/client";
+
+// Mock Console
+vi.spyOn(console, "log").mockImplementation(() => {});
+
+// Mock Prompts
+vi.mock("@clack/prompts", () => ({
+  intro: vi.fn(),
+  outro: vi.fn(),
+  multiselect: vi.fn(),
+  confirm: vi.fn(),
+  cancel: vi.fn(),
+  isCancel: vi.fn((val) => val === Symbol.for("clack:cancel")),
+  spinner: vi.fn(() => ({
+    start: vi.fn(),
+    stop: vi.fn(),
+    message: vi.fn(),
+  })),
+}));
+
+// Manual Mock Client
+const createMockClient = (tables: Record<string, string>[]) => {
+  return {
+    send: async (command: { constructor: { name: string } }) => {
+      const cmdName = command.constructor.name;
+      if (cmdName === "ListTablesCommand") {
+        return { TableNames: tables.map((t) => t.TableName) };
+      }
+      if (cmdName === "DeleteTableCommand") {
+        return {};
+      }
+      return {};
+    },
+  } as unknown;
+};
+
+describe("Drop Command", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test("should handle no tables found", async () => {
+    const client = createMockClient([]) as unknown;
+    await dropCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      client: client as any,
+    });
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("No tables found"));
+    expect(prompts.multiselect).not.toHaveBeenCalled();
+  });
+
+  test("should delete selected tables after confirmation", async () => {
+    const mockTables = [{ TableName: "users" }, { TableName: "posts" }];
+    const client = createMockClient(mockTables) as { send: (cmd: unknown) => Promise<unknown> };
+    const sendSpy = vi.spyOn(client, "send");
+
+    (
+      prompts.multiselect as unknown as { mockResolvedValueOnce: (val: unknown) => void }
+    ).mockResolvedValueOnce(["users"]);
+    (
+      prompts.confirm as unknown as { mockResolvedValueOnce: (val: unknown) => void }
+    ).mockResolvedValueOnce(true);
+
+    await dropCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      client: client as any,
+    });
+
+    // Verify ListTables was called
+    expect((sendSpy.mock.calls[0]![0] as { constructor: { name: string } }).constructor.name).toBe(
+      "ListTablesCommand",
+    );
+
+    // Verify multiselect was called with options
+    expect(prompts.multiselect).toHaveBeenCalled();
+
+    // Verify confirm was called
+    expect(prompts.confirm).toHaveBeenCalled();
+
+    // Verify DeleteTable was called for 'users'
+    // Note: The order of calls depends on implementation, but we expect at least one DeleteTableCommand
+    const calls = sendSpy.mock.calls as { input: { TableName: string } }[][];
+    const deleteCall = calls.find(
+      (call) =>
+        (call[0] as unknown as { constructor: { name: string } }).constructor.name ===
+        "DeleteTableCommand",
+    );
+    expect(deleteCall).toBeDefined();
+    expect(deleteCall![0]!.input.TableName).toBe("users");
+
+    expect(prompts.outro).toHaveBeenCalled();
+  });
+
+  test("should not delete if confirmation is rejected", async () => {
+    const mockTables = [{ TableName: "users" }];
+    const client = createMockClient(mockTables) as { send: (cmd: unknown) => Promise<unknown> };
+    const sendSpy = vi.spyOn(client, "send");
+
+    (
+      prompts.multiselect as unknown as { mockResolvedValueOnce: (val: unknown) => void }
+    ).mockResolvedValueOnce(["users"]);
+    (
+      prompts.confirm as unknown as { mockResolvedValueOnce: (val: unknown) => void }
+    ).mockResolvedValueOnce(false); // User says No
+
+    await dropCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      client: client as any,
+    });
+
+    // Verify DeleteTable was NOT called
+    const calls = sendSpy.mock.calls;
+    const deleteCall = calls.find(
+      (call) =>
+        (call[0] as unknown as { constructor: { name: string } }).constructor.name ===
+        "DeleteTableCommand",
+    );
+    expect(deleteCall).toBeUndefined();
+
+    expect(console.log).toHaveBeenCalledWith(expect.stringContaining("Operation cancelled"));
+  });
+
+  test("should handle cancellation at selection", async () => {
+    const mockTables = [{ TableName: "users" }];
+    const client = createMockClient(mockTables) as unknown;
+
+    // Simulate cancellation symbol
+    const cancelSymbol = Symbol.for("clack:cancel");
+    (
+      prompts.multiselect as unknown as { mockResolvedValueOnce: (val: unknown) => void }
+    ).mockResolvedValueOnce(cancelSymbol);
+    vi.mocked(prompts.isCancel).mockReturnValueOnce(true);
+
+    await dropCommand({
+      config: { schema: "dummy", out: "dummy" } as any,
+      client: client as any,
+    });
+
+    expect(prompts.cancel).toHaveBeenCalled();
+    expect(prompts.confirm).not.toHaveBeenCalled();
+  });
+});

package/test/e2e-env.test.ts

@@ -0,0 +1,87 @@
+import { expect, test, describe, beforeAll, afterAll } from "vitest";
+import { spawnSync } from "child_process";
+import { mkdirSync, rmSync, readdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+const TEMP_DIR = join(tmpdir(), "mizzle-e2e-env-test-" + Date.now());
+const MIGRATIONS_DIR = join(TEMP_DIR, "migrations");
+const ENV_MIGRATIONS_DIR = join(TEMP_DIR, "migrations-env");
+const SCHEMA_FILE = join(TEMP_DIR, "schema.ts");
+const CONFIG_FILE = join(TEMP_DIR, "mizzle.config.ts");
+
+describe("CLI E2E Environment Overrides", () => {
+  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 mizzlingConfigPath = join(projectRoot, "packages/mizzling/src/config");
+  const mizzlingCliPath = join(projectRoot, "packages/mizzling/src/cli.ts");
+
+  beforeAll(() => {
+    mkdirSync(TEMP_DIR, { recursive: true });
+    mkdirSync(MIGRATIONS_DIR, { recursive: true });
+    mkdirSync(ENV_MIGRATIONS_DIR, { recursive: true });
+
+    // Create a simple schema
+    writeFileSync(
+      SCHEMA_FILE,
+      `
+import { dynamoTable } from "${mizzleTablePath}";
+import { string } from "${mizzleColumnsPath}";
+
+export const testTable = dynamoTable("e2e_env_test_table", {
+    pk: string("pk"),
+});
+        `.trim(),
+    );
+
+    // Create config pointing to MIGRATIONS_DIR
+    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("MIZZLE_OUT should override config.out", async () => {
+    // Run generate with MIZZLE_OUT pointing to ENV_MIGRATIONS_DIR
+    const result = spawnSync(
+      "bun",
+      [mizzlingCliPath, "generate", "--name", "env_override"],
+      {
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          MIZZLE_CONFIG: CONFIG_FILE,
+          MIZZLE_OUT: ENV_MIGRATIONS_DIR,
+        },
+        encoding: "utf-8",
+      },
+    );
+
+    if (result.status !== 0) {
+      console.error("Generate failed!");
+      console.error("STDOUT:", result.stdout);
+      console.error("STDERR:", result.stderr);
+    }
+
+    expect(result.status).toBe(0);
+
+    // Should have created migration in ENV_MIGRATIONS_DIR, NOT MIGRATIONS_DIR
+    expect(readdirSync(ENV_MIGRATIONS_DIR).some((f) => f.endsWith("_env_override.ts"))).toBe(true);
+    expect(readdirSync(MIGRATIONS_DIR).length).toBe(0);
+  }, 20000);
+});