@intentius/chant 0.46.0 → 0.50.0

package/src/toml.test.ts

@@ -1,388 +1,161 @@
 import { describe, test, expect } from "vitest";
-import { emitTOML, parseTOML } from "./toml";
-
-describe("emitTOML", () => {
-  test("emits scalar values", () => {
-    const result = emitTOML({
-      name: "my-project",
-      version: 42,
-      enabled: true,
-      ratio: 3.14,
-    });
-    expect(result).toBe(
-      `name = "my-project"\nversion = 42\nenabled = true\nratio = 3.14\n`,
-    );
-  });
-
-  test("emits arrays of scalars inline", () => {
-    const result = emitTOML({
-      schemas: ["public", "audit"],
-      ports: [8080, 9090],
-    });
-    expect(result).toContain('schemas = ["public", "audit"]');
-    expect(result).toContain("ports = [8080, 9090]");
-  });
-
-  test("emits nested tables as sections", () => {
-    const result = emitTOML({
-      name: "proj",
-      flyway: {
-        locations: ["filesystem:sql"],
-        encoding: "UTF-8",
-      },
-    });
-    expect(result).toContain('name = "proj"');
-    expect(result).toContain("[flyway]");
-    expect(result).toContain('locations = ["filesystem:sql"]');
-    expect(result).toContain('encoding = "UTF-8"');
-  });
-
-  test("emits deeply nested tables with dotted paths", () => {
-    const result = emitTOML({
-      environments: {
-        dev: {
-          url: "jdbc:postgresql://localhost:5432/devdb",
-          user: "dev_user",
-        },
-      },
-    });
-    expect(result).toContain("[environments.dev]");
-    expect(result).toContain('url = "jdbc:postgresql://localhost:5432/devdb"');
-  });
-
-  test("emits array of tables", () => {
-    const result = emitTOML({
-      servers: [
-        { host: "alpha", port: 5432 },
-        { host: "beta", port: 5433 },
-      ],
-    });
-    expect(result).toContain("[[servers]]");
-    expect(result).toContain('host = "alpha"');
-    expect(result).toContain("port = 5432");
-    expect(result).toContain('host = "beta"');
-    expect(result).toContain("port = 5433");
-  });
-
-  test("emits header comment", () => {
-    const result = emitTOML({ name: "test" }, { header: "Generated by Chant" });
-    expect(result.startsWith("# Generated by Chant\n")).toBe(true);
-  });
-
-  test("respects key ordering", () => {
-    const result = emitTOML(
-      { z: 1, a: 2, m: 3 },
-      { keyOrder: ["a", "m", "z"] },
-    );
-    const lines = result.split("\n").filter((l) => l.includes("="));
-    expect(lines[0]).toContain("a = 2");
-    expect(lines[1]).toContain("m = 3");
-    expect(lines[2]).toContain("z = 1");
-  });
-
-  test("escapes special characters in strings", () => {
-    const result = emitTOML({
-      path: 'C:\\Users\\admin',
-      query: 'SELECT "name" FROM users',
-    });
-    expect(result).toContain('path = "C:\\\\Users\\\\admin"');
-    expect(result).toContain('query = "SELECT \\"name\\" FROM users"');
-  });
-
-  test("escapes special characters in keys", () => {
-    const result = emitTOML({
-      "simple-key": 1,
-      "key with spaces": 2,
-    });
-    expect(result).toContain("simple-key = 1");
-    expect(result).toContain('"key with spaces" = 2');
-  });
-
-  test("emits empty arrays", () => {
-    const result = emitTOML({ items: [] });
-    expect(result).toContain("items = []");
-  });
-
-  test("emits boolean values correctly", () => {
-    const result = emitTOML({
-      cleanDisabled: true,
-      outOfOrder: false,
-    });
-    expect(result).toContain("cleanDisabled = true");
-    expect(result).toContain("outOfOrder = false");
-  });
-
-  test("handles null/undefined values", () => {
-    const result = emitTOML({
-      present: "yes",
-      absent: null,
-    });
-    expect(result).toContain('present = "yes"');
-    expect(result).toContain('absent = ""');
-  });
-
-  test("skips undefined values", () => {
-    const result = emitTOML({
-      present: "yes",
-      absent: undefined,
-    });
-    expect(result).toContain('present = "yes"');
-    expect(result).not.toContain("absent");
-  });
-
-  test("emits Flyway-realistic config", () => {
-    const result = emitTOML({
-      flyway: {
-        locations: ["filesystem:sql/migrations"],
-        defaultSchema: "public",
-        schemas: ["public", "audit"],
-        encoding: "UTF-8",
-        validateMigrationNaming: true,
-        validateOnMigrate: true,
-        cleanDisabled: true,
-        baselineOnMigrate: false,
-        baselineVersion: "1",
-        sqlMigrationPrefix: "V",
-        sqlMigrationSeparator: "__",
-        sqlMigrationSuffixes: [".sql"],
-        table: "flyway_schema_history",
-        placeholders: {
-          defaultSchema: "public",
-          appName: "myapp",
-        },
-      },
-      environments: {
-        dev: {
-          url: "jdbc:postgresql://localhost:5432/devdb",
-          user: "dev_user",
-          schemas: ["public"],
-        },
-        prod: {
-          url: "jdbc:postgresql://prod-host:5432/proddb",
-          user: "prod_user",
-          schemas: ["public", "audit"],
-        },
-      },
-    });
-
-    expect(result).toContain("[flyway]");
-    expect(result).toContain('[flyway.placeholders]');
-    expect(result).toContain("[environments.dev]");
-    expect(result).toContain("[environments.prod]");
-    expect(result).toContain('defaultSchema = "public"');
-    expect(result).toContain("validateMigrationNaming = true");
-  });
-
-  test("throws for non-object input", () => {
-    expect(() => emitTOML("string" as unknown)).toThrow();
-    expect(() => emitTOML([1, 2, 3] as unknown)).toThrow();
-    expect(() => emitTOML(42 as unknown)).toThrow();
-  });
-});
-
-describe("parseTOML", () => {
-  test("parses scalar values", () => {
-    const result = parseTOML(`
-name = "my-project"
-version = 42
-enabled = true
-ratio = 3.14
-`);
-    expect(result.name).toBe("my-project");
-    expect(result.version).toBe(42);
-    expect(result.enabled).toBe(true);
-    expect(result.ratio).toBe(3.14);
-  });
-
-  test("parses arrays", () => {
-    const result = parseTOML(`
-schemas = ["public", "audit"]
-ports = [8080, 9090]
-`);
-    expect(result.schemas).toEqual(["public", "audit"]);
-    expect(result.ports).toEqual([8080, 9090]);
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { parseTOML, TomlParseError } from "./toml";
+
+describe("parseTOML — spike-grade coverage of real-world TOML (#446)", () => {
+  test("scalars: strings, integers, floats, booleans", () => {
+    const doc = parseTOML(`
+      name = "my-worker"
+      count = 42
+      ratio = 3.14
+      negative = -7
+      enabled = true
+      disabled = false
+      literal = 'raw \\n text'
+    `);
+    expect(doc.name).toBe("my-worker");
+    expect(doc.count).toBe(42);
+    expect(doc.ratio).toBeCloseTo(3.14);
+    expect(doc.negative).toBe(-7);
+    expect(doc.enabled).toBe(true);
+    expect(doc.disabled).toBe(false);
+    expect(doc.literal).toBe("raw \\n text");
+  });
+
+  test("double-quoted string escapes", () => {
+    const doc = parseTOML(`s = "line1\\nline2\\ttabbed \\"quoted\\""`);
+    expect(doc.s).toBe('line1\nline2\ttabbed "quoted"');
+  });
+
+  test("comments are ignored", () => {
+    const doc = parseTOML(`
+      # a top comment
+      a = 1 # trailing comment
+      # another
+      b = 2
+    `);
+    expect(doc).toEqual({ a: 1, b: 2 });
+  });
+
+  test("arrays: single-line and multi-line", () => {
+    const doc = parseTOML(`
+      inline = [1, 2, 3]
+      multi = [
+        "a",
+        "b",
+        "c",
+      ]
+    `);
+    expect(doc.inline).toEqual([1, 2, 3]);
+    expect(doc.multi).toEqual(["a", "b", "c"]);
+  });
+
+  test("inline tables", () => {
+    const doc = parseTOML(`route = { pattern = "api.example.com/*", zone_name = "example.com" }`);
+    expect(doc.route).toEqual({ pattern: "api.example.com/*", zone_name: "example.com" });
+  });
+
+  test("array of inline tables", () => {
+    const doc = parseTOML(`routes = [{ pattern = "a/*", zone_name = "a.com" }, { pattern = "b/*", zone_name = "b.com" }]`);
+    expect(doc.routes).toEqual([
+      { pattern: "a/*", zone_name: "a.com" },
+      { pattern: "b/*", zone_name: "b.com" },
+    ]);
+  });
+
+  test("standard tables, nested dotted tables", () => {
+    const doc = parseTOML(`
+      [observability]
+      enabled = false
+
+      [env.production]
+      workers_dev = false
+
+      [env.production.vars]
+      ENVIRONMENT = "production"
+    `);
+    expect(doc.observability).toEqual({ enabled: false });
+    expect(doc.env).toEqual({ production: { workers_dev: false, vars: { ENVIRONMENT: "production" } } });
+  });
+
+  test("arrays of tables accumulate entries", () => {
+    const doc = parseTOML(`
+      [[kv_namespaces]]
+      binding = "MY_KV"
+      id = "abc123"
+
+      [[kv_namespaces]]
+      binding = "OTHER_KV"
+      id = "def456"
+    `);
+    expect(doc.kv_namespaces).toEqual([
+      { binding: "MY_KV", id: "abc123" },
+      { binding: "OTHER_KV", id: "def456" },
+    ]);
+  });
+
+  test("dotted keys create nested tables inline", () => {
+    const doc = parseTOML(`a.b.c = 1\na.b.d = 2`);
+    expect(doc.a).toEqual({ b: { c: 1, d: 2 } });
+  });
+
+  test("a full representative wrangler.toml", () => {
+    const src = `
+      name = "my-worker"
+      main = "src/index.ts"
+      compatibility_date = "2024-01-01"
+      workers_dev = true
+
+      [observability]
+      enabled = false
+
+      [vars]
+      ENVIRONMENT = "production"
+
+      [[kv_namespaces]]
+      binding = "MY_KV"
+      id = "abc123"
+
+      [[r2_buckets]]
+      binding = "MY_BUCKET"
+      bucket_name = "my-bucket"
+
+      [triggers]
+      crons = ["0 0 * * *"]
+
+      [[routes]]
+      pattern = "example.com/*"
+      zone_name = "example.com"
+
+      [env.production]
+      workers_dev = false
+
+      [env.production.vars]
+      ENVIRONMENT = "production"
+    `;
+    const doc = parseTOML(src);
+    expect(doc.name).toBe("my-worker");
+    expect(doc.workers_dev).toBe(true);
+    expect(doc.observability).toEqual({ enabled: false });
+    expect(doc.vars).toEqual({ ENVIRONMENT: "production" });
+    expect(doc.kv_namespaces).toEqual([{ binding: "MY_KV", id: "abc123" }]);
+    expect(doc.r2_buckets).toEqual([{ binding: "MY_BUCKET", bucket_name: "my-bucket" }]);
+    expect(doc.triggers).toEqual({ crons: ["0 0 * * *"] });
+    expect(doc.routes).toEqual([{ pattern: "example.com/*", zone_name: "example.com" }]);
+    expect(doc.env).toEqual({ production: { workers_dev: false, vars: { ENVIRONMENT: "production" } } });
+  });
+
+  test("throws TomlParseError on malformed input, rather than a generic error", () => {
+    expect(() => parseTOML("a = ")).toThrow(TomlParseError);
+    expect(() => parseTOML("[unterminated")).toThrow(TomlParseError);
+    expect(() => parseTOML('a = "unterminated')).toThrow(TomlParseError);
   });
-
-  test("parses table sections", () => {
-    const result = parseTOML(`
-[flyway]
-encoding = "UTF-8"
-cleanDisabled = true
-`);
-    const flyway = result.flyway as Record<string, unknown>;
-    expect(flyway.encoding).toBe("UTF-8");
-    expect(flyway.cleanDisabled).toBe(true);
-  });
-
-  test("parses dotted table paths", () => {
-    const result = parseTOML(`
-[environments.dev]
-url = "jdbc:postgresql://localhost:5432/devdb"
-user = "dev_user"
-`);
-    const envs = result.environments as Record<string, unknown>;
-    const dev = envs.dev as Record<string, unknown>;
-    expect(dev.url).toBe("jdbc:postgresql://localhost:5432/devdb");
-    expect(dev.user).toBe("dev_user");
-  });
-
-  test("parses array of tables", () => {
-    const result = parseTOML(`
-[[servers]]
-host = "alpha"
-port = 5432
-
-[[servers]]
-host = "beta"
-port = 5433
-`);
-    const servers = result.servers as Record<string, unknown>[];
-    expect(servers).toHaveLength(2);
-    expect(servers[0].host).toBe("alpha");
-    expect(servers[0].port).toBe(5432);
-    expect(servers[1].host).toBe("beta");
-    expect(servers[1].port).toBe(5433);
-  });
-
-  test("ignores comments", () => {
-    const result = parseTOML(`
-# This is a comment
-name = "test" # inline comment
-# Another comment
-version = 1
-`);
-    expect(result.name).toBe("test");
-    expect(result.version).toBe(1);
-  });
-
-  test("parses boolean values", () => {
-    const result = parseTOML(`
-enabled = true
-disabled = false
-`);
-    expect(result.enabled).toBe(true);
-    expect(result.disabled).toBe(false);
-  });
-
-  test("parses inline tables", () => {
-    const result = parseTOML(`
-point = { x = 1, y = 2 }
-`);
-    const point = result.point as Record<string, unknown>;
-    expect(point.x).toBe(1);
-    expect(point.y).toBe(2);
-  });
-
-  test("parses literal strings (single quotes)", () => {
-    const result = parseTOML(`
-path = 'C:\\Users\\admin'
-`);
-    expect(result.path).toBe("C:\\Users\\admin");
-  });
-
-  test("parses escaped strings", () => {
-    const result = parseTOML(`
-escaped = "line1\\nline2"
-`);
-    expect(result.escaped).toBe("line1\nline2");
-  });
-
-  test("parses empty values", () => {
-    const result = parseTOML(`
-empty_string = ""
-empty_array = []
-`);
-    expect(result.empty_string).toBe("");
-    expect(result.empty_array).toEqual([]);
-  });
-
-  test("parses Flyway-realistic config", () => {
-    const result = parseTOML(`
-[flyway]
-locations = ["filesystem:sql/migrations"]
-defaultSchema = "public"
-schemas = ["public", "audit"]
-encoding = "UTF-8"
-validateMigrationNaming = true
-cleanDisabled = true
-baselineVersion = "1"
-table = "flyway_schema_history"
-
-[flyway.placeholders]
-defaultSchema = "public"
-appName = "myapp"
-
-[environments.dev]
-url = "jdbc:postgresql://localhost:5432/devdb"
-user = "dev_user"
-schemas = ["public"]
-
-[environments.prod]
-url = "jdbc:postgresql://prod-host:5432/proddb"
-user = "prod_user"
-schemas = ["public", "audit"]
-`);
-
-    const flyway = result.flyway as Record<string, unknown>;
-    expect(flyway.defaultSchema).toBe("public");
-    expect(flyway.validateMigrationNaming).toBe(true);
-    expect((flyway.placeholders as Record<string, unknown>).appName).toBe("myapp");
-
-    const envs = result.environments as Record<string, unknown>;
-    const dev = envs.dev as Record<string, unknown>;
-    expect(dev.url).toBe("jdbc:postgresql://localhost:5432/devdb");
-
-    const prod = envs.prod as Record<string, unknown>;
-    expect(prod.schemas).toEqual(["public", "audit"]);
-  });
-});
-
-describe("roundtrip", () => {
-  test("emit → parse → emit preserves structure", () => {
-    const original = {
-      name: "roundtrip-test",
-      flyway: {
-        locations: ["filesystem:sql"],
-        encoding: "UTF-8",
-        cleanDisabled: true,
-        baselineVersion: "1",
-        placeholders: {
-          schema: "public",
-        },
-      },
-      environments: {
-        dev: {
-          url: "jdbc:postgresql://localhost:5432/db",
-          user: "admin",
-          schemas: ["public"],
-        },
-      },
-    };
-
-    const toml = emitTOML(original);
-    const parsed = parseTOML(toml);
-    const toml2 = emitTOML(parsed);
-
-    expect(toml2).toBe(toml);
-  });
-
-  test("roundtrip with booleans and numbers", () => {
-    const original = {
-      settings: {
-        enabled: true,
-        disabled: false,
-        count: 42,
-        ratio: 3.14,
-      },
-    };
-
-    const toml = emitTOML(original);
-    const parsed = parseTOML(toml);
-
-    const settings = parsed.settings as Record<string, unknown>;
-    expect(settings.enabled).toBe(true);
-    expect(settings.disabled).toBe(false);
-    expect(settings.count).toBe(42);
-    expect(settings.ratio).toBe(3.14);
+
+  test("is pure: no fs/network globals referenced (Workers-safety smoke check)", () => {
+    const src = readFileSync(fileURLToPath(new URL("./toml.ts", import.meta.url)), "utf-8");
+    expect(src).not.toMatch(/\brequire\(/);
+    expect(src).not.toMatch(/\bfetch\(/);
+    expect(src).not.toMatch(/\bimport\.meta\.url\b/);
   });
 });