@roster-lock/config-editor-cli 0.0.1

package/tests/lib/errors.spec.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, vi } from "vitest";
+import { ErrorObject } from "ajv";
+import { formatError, withErrorHandling } from "../../src/lib/errors";
+
+describe("formatError", () => {
+  it("formats a plain Error by its message", () => {
+    expect(formatError(new Error("boom"))).toBe("boom");
+  });
+
+  it("formats an array of AJV ErrorObjects, one per line", () => {
+    const errors: Array<ErrorObject> = [
+      { instancePath: "/foo", schemaPath: "", keyword: "type", message: "must be string", params: {} },
+      { instancePath: "", schemaPath: "", keyword: "required", message: "must have required property 'bar'", params: {} },
+    ];
+    expect(formatError(errors)).toBe(
+      "/foo must be string\n/ must have required property 'bar'"
+    );
+  });
+
+  it("stringifies anything else", () => {
+    expect(formatError("plain string")).toBe("plain string");
+    expect(formatError(42)).toBe("42");
+  });
+});
+
+describe("withErrorHandling", () => {
+  it("runs the wrapped function and does not touch exitCode on success", async () => {
+    process.exitCode = undefined;
+    const fn = vi.fn(async (x: number) => { void x; });
+    await withErrorHandling(fn)(1);
+    expect(fn).toHaveBeenCalledWith(1);
+    expect(process.exitCode).toBeUndefined();
+  });
+
+  it("logs the formatted error and sets exitCode to 1 on failure", async () => {
+    process.exitCode = undefined;
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const fn = async () => { throw new Error("nope"); };
+
+    await withErrorHandling(fn)();
+
+    expect(errorSpy).toHaveBeenCalledWith("nope");
+    expect(process.exitCode).toBe(1);
+
+    errorSpy.mockRestore();
+    process.exitCode = undefined;
+  });
+});

package/tests/lib/fs-walk.spec.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as pathJoin } from "node:path";
+import { walkRelative, getFileFromRoot } from "../../src/lib/fs-walk";
+
+describe("fs-walk", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(pathJoin(tmpdir(), "rosterlock-fs-walk-"));
+    mkdirSync(pathJoin(tempDir, "nested"));
+    writeFileSync(pathJoin(tempDir, "top.txt"), "top");
+    writeFileSync(pathJoin(tempDir, "nested", "inner.txt"), "inner");
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("yields all files recursively as forward-slash relative paths", async () => {
+    const paths: Array<string> = [];
+    for await (const p of walkRelative(tempDir)) paths.push(p);
+    expect(paths.sort()).toEqual(["nested/inner.txt", "top.txt"]);
+  });
+
+  it("resolves file size and a readable stream from root", async () => {
+    const { byteSize, stream } = await getFileFromRoot(tempDir, "top.txt");
+    expect(byteSize).toBe(3);
+
+    const chunks: Array<Buffer> = [];
+    for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+    expect(Buffer.concat(chunks).toString("utf-8")).toBe("top");
+  });
+});

package/tests/lib/json-input.spec.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join as pathJoin } from "node:path";
+import { Readable } from "node:stream";
+import { z } from "zod";
+import { readJsonInput } from "../../src/lib/json-input";
+
+const fooSchema = z.object({ foo: z.string() }).strict();
+
+describe("readJsonInput", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(pathJoin(tmpdir(), "rosterlock-json-input-"));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("reads, parses, and validates JSON from a file path", async () => {
+    const filePath = pathJoin(tempDir, "data.json");
+    writeFileSync(filePath, JSON.stringify({ foo: "bar" }));
+
+    await expect(readJsonInput(filePath, fooSchema)).resolves.toEqual({ foo: "bar" });
+  });
+
+  it("collects, parses, and validates JSON from stdin when given \"-\"", async () => {
+    const originalStdin = process.stdin;
+    Object.defineProperty(process, "stdin", {
+      value: Readable.from([JSON.stringify({ foo: "stdin" })]),
+      configurable: true,
+    });
+
+    try {
+      await expect(readJsonInput("-", fooSchema)).resolves.toEqual({ foo: "stdin" });
+    } finally {
+      Object.defineProperty(process, "stdin", { value: originalStdin, configurable: true });
+    }
+  });
+
+  it("throws on invalid JSON", async () => {
+    const filePath = pathJoin(tempDir, "bad.json");
+    writeFileSync(filePath, "{not valid json");
+
+    await expect(readJsonInput(filePath, fooSchema)).rejects.toThrow();
+  });
+
+  it("throws a ZodError when the JSON doesn't match the schema", async () => {
+    const filePath = pathJoin(tempDir, "wrong-shape.json");
+    writeFileSync(filePath, JSON.stringify({ foo: 42 }));
+
+    await expect(readJsonInput(filePath, fooSchema)).rejects.toThrow(z.ZodError);
+  });
+
+  it("rejects unknown properties (schemas are declared .strict())", async () => {
+    const filePath = pathJoin(tempDir, "extra-props.json");
+    writeFileSync(filePath, JSON.stringify({ foo: "bar", extra: true }));
+
+    await expect(readJsonInput(filePath, fooSchema)).rejects.toThrow(z.ZodError);
+  });
+});

package/tests/lib/parse.spec.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect } from "vitest";
+import { parseKeyValueList, parseCommaList, parseCount, parseStrategy } from "../../src/lib/parse";
+
+describe("parseKeyValueList", () => {
+  it("returns an empty object for undefined", () => {
+    expect(parseKeyValueList(undefined)).toEqual({});
+  });
+
+  it("parses comma-separated key=value pairs", () => {
+    expect(parseKeyValueList("a=1,b=2")).toEqual({ a: "1", b: "2" });
+  });
+
+  it("trims whitespace around pairs", () => {
+    expect(parseKeyValueList(" a=1 , b=2 ")).toEqual({ a: "1", b: "2" });
+  });
+
+  it("skips empty segments", () => {
+    expect(parseKeyValueList("a=1,,b=2")).toEqual({ a: "1", b: "2" });
+  });
+
+  it("allows '=' inside the value", () => {
+    expect(parseKeyValueList("a=1=2")).toEqual({ a: "1=2" });
+  });
+
+  it("throws on a segment with no '='", () => {
+    expect(() => parseKeyValueList("a=1,bad")).toThrow(/Invalid key=value pair/);
+  });
+});
+
+describe("parseCommaList", () => {
+  it("returns an empty array for undefined", () => {
+    expect(parseCommaList(undefined)).toEqual([]);
+  });
+
+  it("splits and trims", () => {
+    expect(parseCommaList(" a, b ,c")).toEqual(["a", "b", "c"]);
+  });
+
+  it("drops empty entries", () => {
+    expect(parseCommaList("a,,b,")).toEqual(["a", "b"]);
+  });
+});
+
+describe("parseCount", () => {
+  it("parses '*' as-is", () => {
+    expect(parseCount("*")).toBe("*");
+  });
+
+  it("parses a plain integer", () => {
+    expect(parseCount("3")).toBe(3);
+  });
+
+  it("throws on a non-numeric plain value", () => {
+    expect(() => parseCount("abc")).toThrow(/Invalid count/);
+  });
+
+  it("parses a min:max range", () => {
+    expect(parseCount("1:5")).toEqual([1, 5]);
+  });
+
+  it("parses a min:* range", () => {
+    expect(parseCount("1:*")).toEqual([1, "*"]);
+  });
+
+  it("throws on an invalid range", () => {
+    expect(() => parseCount("a:5")).toThrow(/Invalid count range/);
+    expect(() => parseCount("1:b")).toThrow(/Invalid count range/);
+  });
+});
+
+describe("parseStrategy", () => {
+  it("passes through valid strategies", () => {
+    expect(parseStrategy("mandatory")).toBe("mandatory");
+    expect(parseStrategy("personal")).toBe("personal");
+    expect(parseStrategy("shared")).toBe("shared");
+  });
+
+  it("normalizes 'on-demand' to 'on demand'", () => {
+    expect(parseStrategy("on-demand")).toBe("on demand");
+  });
+
+  it("throws on an unknown strategy", () => {
+    expect(() => parseStrategy("bogus")).toThrow(/Invalid strategy/);
+  });
+});

package/tests/lib/schema-help.spec.ts

@@ -0,0 +1,42 @@
+import { describe, it, expect } from "vitest";
+import { z } from "zod";
+import { describeSchemaShape } from "../../src/lib/schema-help";
+
+describe("describeSchemaShape", () => {
+  it("renders primitives and objects", () => {
+    const schema = z.object({ name: z.string(), age: z.number(), active: z.boolean() }).strict();
+    expect(describeSchemaShape(schema)).toBe("{ name: string, age: number, active: boolean }");
+  });
+
+  it("marks optional fields with a trailing ?", () => {
+    const schema = z.object({ name: z.string(), nickname: z.string().optional() }).strict();
+    expect(describeSchemaShape(schema)).toBe("{ name: string, nickname?: string }");
+  });
+
+  it("renders arrays, tuples, unions, enums, and literals", () => {
+    const schema = z.object({
+      tags: z.array(z.string()),
+      pair: z.tuple([z.number(), z.string()]),
+      mode: z.union([z.string(), z.number()]),
+      kind: z.enum(["a", "b"]),
+      star: z.literal("*"),
+    }).strict();
+
+    expect(describeSchemaShape(schema)).toBe(
+      '{ tags: string[], pair: [number, string], mode: string | number, kind: "a" | "b", star: "*" }'
+    );
+  });
+
+  it("renders records", () => {
+    const schema = z.record(z.string(), z.number());
+    expect(describeSchemaShape(schema)).toBe("Record<string, number>");
+  });
+
+  it("renders a placeholder for recursive (lazy) schemas instead of infinitely recursing", () => {
+    type Node = { children: Array<Node> };
+    const nodeSchema: z.ZodType<Node> = z.lazy(() => z.object({ children: z.array(nodeSchema) }).strict());
+    const schema = z.object({ root: nodeSchema }).strict();
+
+    expect(describeSchemaShape(schema)).toBe("{ root: <recursive> }");
+  });
+});

package/tests/lib/schemas.spec.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect } from "vitest";
+import { pieceDefinitionSchema, pieceOverridesSchema, selectionOverridesSchemas } from "../../src/lib/schemas";
+
+describe("pieceDefinitionSchema", () => {
+  const valid = {
+    selectionStrategy: "mandatory",
+    requires: [],
+    pathVariables: ["skin"],
+    assets: [{ name: "sprite", classification: "media", count: 1, glob: ["*.png"] }],
+  };
+
+  it("accepts a well-formed piece definition", () => {
+    expect(pieceDefinitionSchema.parse(valid)).toEqual(valid);
+  });
+
+  it("accepts count as '*' or a [min, max] range", () => {
+    expect(() => pieceDefinitionSchema.parse({ ...valid, assets: [{ ...valid.assets[0], count: "*" }] })).not.toThrow();
+    expect(() => pieceDefinitionSchema.parse({ ...valid, assets: [{ ...valid.assets[0], count: [1, "*"] }] })).not.toThrow();
+  });
+
+  it("rejects an invalid selectionStrategy", () => {
+    expect(() => pieceDefinitionSchema.parse({ ...valid, selectionStrategy: "bogus" })).toThrow();
+  });
+
+  it("rejects unknown top-level properties", () => {
+    expect(() => pieceDefinitionSchema.parse({ ...valid, extra: true })).toThrow();
+  });
+
+  it("rejects an asset missing required fields", () => {
+    expect(() => pieceDefinitionSchema.parse({ ...valid, assets: [{ name: "sprite" }] })).toThrow();
+  });
+});
+
+describe("pieceOverridesSchema", () => {
+  it("accepts a fully-populated overrides object", () => {
+    const input = {
+      humanInfo: { name: "Blue", author: "author", url: "https://example.com", image: "https://example.com/i.png" },
+      downloadSources: ["https://example.com/blue.tar"],
+      pathVariables: { skin: "blue" },
+    };
+    expect(pieceOverridesSchema.parse(input)).toEqual(input);
+  });
+
+  it("accepts an empty object (all fields optional)", () => {
+    expect(pieceOverridesSchema.parse({})).toEqual({});
+  });
+
+  it("rejects humanInfo missing a required field", () => {
+    expect(() => pieceOverridesSchema.parse({ humanInfo: { name: "Blue" } })).toThrow();
+  });
+
+  it("rejects non-string pathVariables values", () => {
+    expect(() => pieceOverridesSchema.parse({ pathVariables: { skin: 1 } })).toThrow();
+  });
+});
+
+describe("selectionOverridesSchemas", () => {
+  it("normal accepts validation and mergeAlgorithm", () => {
+    const input = {
+      validation: { count: "*", unique: false, banList: [], customValidation: [] },
+      mergeAlgorithm: { src: "merge.ts" },
+    };
+    expect(() => selectionOverridesSchemas.normal.parse(input)).not.toThrow();
+  });
+
+  it("normal rejects a 'pieces' field (that's preselected-only)", () => {
+    expect(() => selectionOverridesSchemas.normal.parse({ pieces: [] })).toThrow();
+  });
+
+  it("preselected accepts a pieces list, including nested required pieces", () => {
+    const input = {
+      pieces: [{ id: "@a/b", required: { minion: { mandatory: [], selectable: [] } } }],
+    };
+    expect(() => selectionOverridesSchemas.preselected.parse(input)).not.toThrow();
+  });
+
+  it("unselectable and game-controlled accept no override fields", () => {
+    expect(() => selectionOverridesSchemas.unselectable.parse({})).not.toThrow();
+    expect(() => selectionOverridesSchemas.unselectable.parse({ pieces: [] })).toThrow();
+    expect(() => selectionOverridesSchemas["game-controlled"].parse({})).not.toThrow();
+  });
+});

package/tests/lib/slugify.spec.ts

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { slugify } from "../../src/lib/slugify";
+
+describe("slugify", () => {
+  it("lowercases and replaces spaces with dashes", () => {
+    expect(slugify("Hello World")).toBe("hello-world");
+  });
+
+  it("replaces underscores with dashes", () => {
+    expect(slugify("hello_world")).toBe("hello-world");
+  });
+
+  it("strips characters outside a-z0-9-", () => {
+    expect(slugify("Hello, World! 2.0")).toBe("hello-world-20");
+  });
+
+  it("trims leading/trailing dashes", () => {
+    expect(slugify("  --hello--  ")).toBe("hello");
+  });
+
+  it("collapses repeated dashes", () => {
+    expect(slugify("a---b")).toBe("a-b");
+  });
+
+  it("returns an empty string for input with no valid characters", () => {
+    expect(slugify("!!!")).toBe("");
+  });
+});

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "es2024",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "types": ["node"],
+    "lib": ["es2024"],
+    "sourceMap": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "removeComments": true,
+    "noImplicitAny": true
+  },
+  "include": ["src/**/*.ts", "./typings", "./types", "./@types"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/tsconfig.test.json

@@ -0,0 +1,10 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": true
+  },
+  "files": [],
+  "include": ["./typings", "./types", "tests/**/*.ts"],
+  "exclude": ["node_modules"]
+}