@caleuche/cli 0.1.4 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @caleuche/cli
 
+## 0.2.1
+
+### Patch Changes
+
+- Updated dependencies [d0f1a56]
+  - @caleuche/core@0.2.0
+
+## 0.2.0
+
+### Minor Changes
+
+- 15ef5f4: Adding batch compile command.
+
 ## 0.1.4
 
 ### Patch Changes

package/dist/batch.js

@@ -0,0 +1,98 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.batchCompile = batchCompile;
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils");
+const common_1 = require("./common");
+function loadVariantDefinition(variant) {
+    if ((0, utils_1.isVariantDefinition)(variant)) {
+        return variant;
+    }
+    else if ((0, utils_1.isVariantPath)(variant)) {
+        const v = (0, utils_1.parse)(variant);
+        if (!v) {
+            console.error(`Failed to parse variant at path: ${variant}`);
+            return null;
+        }
+        return v;
+    }
+    return null;
+}
+function loadVariantDefinitions(variants) {
+    if (!variants)
+        return {};
+    const definitions = {};
+    for (const [key, variant] of Object.entries(variants)) {
+        const v = loadVariantDefinition(variant);
+        if (!v) {
+            console.error(`Failed to load variant definition for key "${key}": ${variant}`);
+            return null;
+        }
+        definitions[key] = v;
+    }
+    return definitions;
+}
+function resolveVariantDefinition(variant, variantRegistry) {
+    if ((0, utils_1.isVariantPath)(variant)) {
+        const v = (0, utils_1.parse)(variant);
+        if (!v) {
+            console.error(`Failed to parse variant at path: ${variant}`);
+            return null;
+        }
+        return v;
+    }
+    else if ((0, utils_1.isVariantDefinition)(variant)) {
+        return variant;
+    }
+    else if ((0, utils_1.isVariantReference)(variant)) {
+        const v = variantRegistry[variant];
+        if (!v) {
+            console.error(`Variant reference "${variant}" not found in registry.`);
+            return null;
+        }
+        return v;
+    }
+    console.error(`Invalid variant type: ${JSON.stringify(variant)}`);
+    return null;
+}
+function batchCompile(batchFile) {
+    if (!fs_1.default.existsSync(batchFile)) {
+        console.error(`Batch file "${batchFile}" does not exist.`);
+        process.exit(1);
+    }
+    if (!fs_1.default.lstatSync(batchFile).isFile()) {
+        console.error(`"${batchFile}" is not a file.`);
+        process.exit(1);
+    }
+    const bachDefinition = (0, utils_1.parse)(batchFile);
+    if (!bachDefinition) {
+        console.error(`Failed to parse batch file: ${batchFile}`);
+        process.exit(1);
+    }
+    const variants = loadVariantDefinitions(bachDefinition.variants);
+    if (!variants) {
+        process.exit(1);
+    }
+    const samples = bachDefinition.samples;
+    for (const sampleDefinition of samples) {
+        const sample = (0, common_1.resolveAndParseSample)(sampleDefinition.templatePath);
+        if (!sample) {
+            process.exit(1);
+        }
+        for (const variant of sampleDefinition.variants) {
+            const resolvedVariant = resolveVariantDefinition(variant, variants);
+            if (!resolvedVariant) {
+                process.exit(1);
+            }
+            if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant, variant.output, {
+                project: true,
+            })) {
+                console.error(`Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`);
+                process.exit(1);
+            }
+        }
+    }
+}

package/dist/common.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAndParseSample = resolveAndParseSample;
+exports.compileAndWriteOutput = compileAndWriteOutput;
+const core_1 = require("@caleuche/core");
+const utils_1 = require("./utils");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function resolveAndParseSample(samplePath) {
+    const sampleFilePath = (0, utils_1.resolveSampleFile)(samplePath);
+    if (!fs_1.default.existsSync(sampleFilePath)) {
+        console.error(`Sample file not found: ${sampleFilePath}`);
+        return null;
+    }
+    const sample = (0, utils_1.parse)(sampleFilePath);
+    if (!sample) {
+        console.error(`Failed to parse sample file: ${sampleFilePath}`);
+        return null;
+    }
+    const resolvedTemplate = (0, utils_1.resolveTemplate)(samplePath, sample);
+    if (!resolvedTemplate) {
+        return null;
+    }
+    sample.template = resolvedTemplate;
+    return sample;
+}
+function compileAndWriteOutput(sample, input, outputPath, options) {
+    const output = (() => {
+        try {
+            return (0, core_1.compileSample)(sample, input, {
+                project: options.project || false,
+            });
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error(`Error during compilation: ${error.message}`);
+            }
+            else {
+                console.error("An unknown error occurred during compilation.");
+            }
+            return null;
+        }
+    })();
+    if (!output) {
+        return false;
+    }
+    try {
+        (0, utils_1.createOutputDirectory)(outputPath);
+        for (const { fileName, content } of output.items) {
+            const itemOutputPath = path_1.default.join(outputPath, fileName);
+            fs_1.default.writeFileSync(itemOutputPath, content);
+        }
+    }
+    catch {
+        console.error(`Failed to write output to ${outputPath}`);
+        return false;
+    }
+    return true;
+}

package/dist/compile.js

@@ -1,56 +1,19 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.compile = compile;
-const core_1 = require("@caleuche/core");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const utils_1 = require("./utils");
+const common_1 = require("./common");
 function compile(samplePath, dataPath, outputPath, options) {
-    const sampleFilePath = (0, utils_1.resolveSampleFile)(samplePath);
-    if (!fs_1.default.existsSync(sampleFilePath)) {
-        console.error(`Sample file not found: ${sampleFilePath}`);
-        process.exit(1);
-    }
-    const sample = (0, utils_1.parse)(sampleFilePath);
+    const sample = (0, common_1.resolveAndParseSample)(samplePath);
     if (!sample) {
-        console.error(`Failed to parse sample file: ${sampleFilePath}`);
-        process.exit(1);
+        return process.exit(1);
     }
-    sample.template = (0, utils_1.resolveTemplate)(samplePath, sample);
     const inputData = (0, utils_1.parse)(dataPath);
     if (!inputData || !(0, utils_1.isObject)(inputData)) {
         console.error(`Failed to parse input data file: ${dataPath}`);
         process.exit(1);
     }
-    const output = (() => {
-        try {
-            return (0, core_1.compileSample)(sample, inputData, {
-                project: options.project || false,
-            });
-        }
-        catch (error) {
-            if (error instanceof Error) {
-                console.error(`Error during compilation: ${error.message}`);
-            }
-            else {
-                console.error("An unknown error occurred during compilation.");
-            }
-            return null;
-        }
-    })();
-    if (!output) {
+    if (!(0, common_1.compileAndWriteOutput)(sample, inputData, outputPath, options)) {
         process.exit(1);
     }
-    if (!(0, utils_1.isObject)(inputData)) {
-        console.error("Input data must be an object.");
-        process.exit(1);
-    }
-    (0, utils_1.createOutputDirectory)(outputPath);
-    for (const { fileName, content } of output.items) {
-        const itemOutputPath = path_1.default.join(outputPath, fileName);
-        fs_1.default.writeFileSync(itemOutputPath, content);
-    }
 }

package/dist/index.js

@@ -12,4 +12,7 @@ commander_1.program
     .command("compile <sample-directory> <data-file> <output-directory>")
     .option("-p, --project", "Generate project file")
     .action(compile_1.compile);
+commander_1.program.command("batch <batch-file>").action((batchFile) => {
+    console.log(`Batch compiling samples from ${batchFile}`);
+});
 commander_1.program.parse();

package/dist/interfaces.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils.js

@@ -9,6 +9,9 @@ exports.isDirectory = isDirectory;
 exports.createOutputDirectory = createOutputDirectory;
 exports.resolveTemplate = resolveTemplate;
 exports.isObject = isObject;
+exports.isVariantDefinition = isVariantDefinition;
+exports.isVariantPath = isVariantPath;
+exports.isVariantReference = isVariantReference;
 const yaml_1 = require("yaml");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -48,9 +51,18 @@ function resolveTemplate(samplePath, sample) {
     }
     catch (error) {
         console.error("Error reading template file.");
-        process.exit(1);
+        return null;
     }
 }
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isVariantDefinition(variant) {
+    return isObject(variant) && !Array.isArray(variant);
+}
+function isVariantPath(variant) {
+    return typeof variant === "string" && fs_1.default.existsSync(variant);
+}
+function isVariantReference(variant) {
+    return typeof variant === "string" && !fs_1.default.existsSync(variant);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.1.4",
+  "version": "0.2.1",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"
@@ -19,7 +19,7 @@
   "license": "MIT",
   "description": "Caleuche CLI",
   "dependencies": {
-    "@caleuche/core": "*",
+    "@caleuche/core": "^0.2.0",
     "commander": "^14.0.0",
     "yaml": "^2.8.0"
   },

package/src/batch.ts

@@ -0,0 +1,112 @@
+import fs from "fs";
+import {
+  isVariantDefinition,
+  isVariantPath,
+  isVariantReference,
+  parse,
+} from "./utils";
+import { compileAndWriteOutput, resolveAndParseSample } from "./common";
+
+function loadVariantDefinition(
+  variant: SampleVariantDefinition | SampleVariantPath,
+): SampleVariantDefinition | null {
+  if (isVariantDefinition(variant)) {
+    return variant;
+  } else if (isVariantPath(variant)) {
+    const v = parse<SampleVariantDefinition>(variant);
+    if (!v) {
+      console.error(`Failed to parse variant at path: ${variant}`);
+      return null;
+    }
+    return v;
+  }
+  return null;
+}
+
+function loadVariantDefinitions(
+  variants?: Record<string, SampleVariantDefinition | SampleVariantPath>,
+): Record<string, SampleVariantDefinition> | null {
+  if (!variants) return {};
+  const definitions: Record<string, SampleVariantDefinition> = {};
+  for (const [key, variant] of Object.entries(variants)) {
+    const v = loadVariantDefinition(variant);
+    if (!v) {
+      console.error(
+        `Failed to load variant definition for key "${key}": ${variant}`,
+      );
+      return null;
+    }
+    definitions[key] = v;
+  }
+  return definitions;
+}
+
+function resolveVariantDefinition(
+  variant: SampleVariant,
+  variantRegistry: Record<string, SampleVariantDefinition>,
+): SampleVariantDefinition | null {
+  if (isVariantPath(variant)) {
+    const v = parse<SampleVariantDefinition>(variant);
+    if (!v) {
+      console.error(`Failed to parse variant at path: ${variant}`);
+      return null;
+    }
+    return v;
+  } else if (isVariantDefinition(variant)) {
+    return variant;
+  } else if (isVariantReference(variant)) {
+    const v = variantRegistry[variant];
+    if (!v) {
+      console.error(`Variant reference "${variant}" not found in registry.`);
+      return null;
+    }
+    return v;
+  }
+  console.error(`Invalid variant type: ${JSON.stringify(variant)}`);
+  return null;
+}
+
+export function batchCompile(batchFile: string) {
+  if (!fs.existsSync(batchFile)) {
+    console.error(`Batch file "${batchFile}" does not exist.`);
+    process.exit(1);
+  }
+  if (!fs.lstatSync(batchFile).isFile()) {
+    console.error(`"${batchFile}" is not a file.`);
+    process.exit(1);
+  }
+  const bachDefinition = parse<BatchCompileOptions>(batchFile);
+  if (!bachDefinition) {
+    console.error(`Failed to parse batch file: ${batchFile}`);
+    process.exit(1);
+  }
+  const variants = loadVariantDefinitions(bachDefinition.variants);
+  if (!variants) {
+    process.exit(1);
+  }
+  const samples = bachDefinition.samples;
+  for (const sampleDefinition of samples) {
+    const sample = resolveAndParseSample(sampleDefinition.templatePath);
+    if (!sample) {
+      process.exit(1);
+    }
+
+    for (const variant of sampleDefinition.variants) {
+      const resolvedVariant = resolveVariantDefinition(variant, variants);
+      if (!resolvedVariant) {
+        process.exit(1);
+      }
+
+      if (
+        !compileAndWriteOutput(sample, resolvedVariant, variant.output, {
+          project: true,
+        })
+      ) {
+        console.error(
+          `Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`,
+        );
+        process.exit(1);
+      }
+    }
+  }
+}

package/src/common.ts

@@ -0,0 +1,67 @@
+import { compileSample, Sample } from "@caleuche/core";
+import {
+  createOutputDirectory,
+  parse,
+  resolveSampleFile,
+  resolveTemplate,
+} from "./utils";
+import fs from "fs";
+import path from "path";
+
+export function resolveAndParseSample(samplePath: string): Sample | null {
+  const sampleFilePath = resolveSampleFile(samplePath);
+  if (!fs.existsSync(sampleFilePath)) {
+    console.error(`Sample file not found: ${sampleFilePath}`);
+    return null;
+  }
+  const sample = parse<Sample>(sampleFilePath);
+  if (!sample) {
+    console.error(`Failed to parse sample file: ${sampleFilePath}`);
+    return null;
+  }
+  const resolvedTemplate = resolveTemplate(samplePath, sample);
+  if (!resolvedTemplate) {
+    return null;
+  }
+  sample.template = resolvedTemplate;
+  return sample;
+}
+
+export function compileAndWriteOutput(
+  sample: Sample,
+  input: object,
+  outputPath: string,
+  options: { project?: boolean },
+) {
+  const output = (() => {
+    try {
+      return compileSample(sample, input, {
+        project: options.project || false,
+      });
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(`Error during compilation: ${error.message}`);
+      } else {
+        console.error("An unknown error occurred during compilation.");
+      }
+      return null;
+    }
+  })();
+
+  if (!output) {
+    return false;
+  }
+
+  try {
+    createOutputDirectory(outputPath);
+
+    for (const { fileName, content } of output.items) {
+      const itemOutputPath = path.join(outputPath, fileName);
+      fs.writeFileSync(itemOutputPath, content);
+    }
+  } catch {
+    console.error(`Failed to write output to ${outputPath}`);
+    return false;
+  }
+  return true;
+}

package/src/compile.ts

@@ -1,13 +1,5 @@
-import { compileSample, Sample } from "@caleuche/core";
-import fs from "fs";
-import path from "path";
-import {
-  createOutputDirectory,
-  isObject,
-  parse,
-  resolveSampleFile,
-  resolveTemplate,
-} from "./utils";
+import { isObject, parse } from "./utils";
+import { compileAndWriteOutput, resolveAndParseSample } from "./common";
 
 export function compile(
   samplePath: string,
@@ -15,18 +7,10 @@ export function compile(
   outputPath: string,
   options: { project?: boolean },
 ) {
-  const sampleFilePath = resolveSampleFile(samplePath);
-  if (!fs.existsSync(sampleFilePath)) {
-    console.error(`Sample file not found: ${sampleFilePath}`);
-    process.exit(1);
-  }
-
-  const sample = parse<Sample>(sampleFilePath);
+  const sample = resolveAndParseSample(samplePath);
   if (!sample) {
-    console.error(`Failed to parse sample file: ${sampleFilePath}`);
-    process.exit(1);
+    return process.exit(1);
   }
-  sample.template = resolveTemplate(samplePath, sample);
 
   const inputData = parse<Record<string, any>>(dataPath);
   if (!inputData || !isObject(inputData)) {
@@ -34,34 +18,7 @@ export function compile(
     process.exit(1);
   }
 
-  const output = (() => {
-    try {
-      return compileSample(sample, inputData, {
-        project: options.project || false,
-      });
-    } catch (error) {
-      if (error instanceof Error) {
-        console.error(`Error during compilation: ${error.message}`);
-      } else {
-        console.error("An unknown error occurred during compilation.");
-      }
-      return null;
-    }
-  })();
-
-  if (!output) {
+  if (!compileAndWriteOutput(sample, inputData, outputPath, options)) {
     process.exit(1);
   }
-
-  if (!isObject(inputData)) {
-    console.error("Input data must be an object.");
-    process.exit(1);
-  }
-
-  createOutputDirectory(outputPath);
-
-  for (const { fileName, content } of output.items) {
-    const itemOutputPath = path.join(outputPath, fileName);
-    fs.writeFileSync(itemOutputPath, content);
-  }
 }

package/src/index.ts

@@ -14,4 +14,8 @@ program
   .option("-p, --project", "Generate project file")
   .action(compile);
 
+program.command("batch <batch-file>").action((batchFile) => {
+  console.log(`Batch compiling samples from ${batchFile}`);
+});
+
 program.parse();

package/src/interfaces.ts

@@ -0,0 +1,22 @@
+type SampleVariantDefinition = Record<string, any>;
+type SampleVariantReference = string;
+type SampleVariantPath = string;
+type SampleVariant =
+  | SampleVariantDefinition
+  | SampleVariantReference
+  | SampleVariantPath;
+
+interface SampleVariantConfig {
+  output: string;
+  data: SampleVariant;
+}
+
+interface SampleDefinition {
+  templatePath: string;
+  variants: SampleVariantConfig[];
+}
+
+interface BatchCompileOptions {
+  variants?: Record<string, SampleVariantDefinition | SampleVariantPath>;
+  samples: SampleDefinition[];
+}

package/src/utils.ts

@@ -32,7 +32,10 @@ export function createOutputDirectory(outputPath: string) {
   }
 }
 
-export function resolveTemplate(samplePath: string, sample: Sample): string {
+export function resolveTemplate(
+  samplePath: string,
+  sample: Sample,
+): string | null {
   try {
     const templatePath = path.join(samplePath, sample.template);
     if (!fs.existsSync(templatePath)) {
@@ -41,10 +44,28 @@ export function resolveTemplate(samplePath: string, sample: Sample): string {
     return fs.readFileSync(templatePath, "utf-8");
   } catch (error) {
     console.error("Error reading template file.");
-    process.exit(1);
+    return null;
   }
 }
 
 export function isObject(value: any): value is Record<string, any> {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+
+export function isVariantDefinition(
+  variant: SampleVariant,
+): variant is SampleVariantDefinition {
+  return isObject(variant) && !Array.isArray(variant);
+}
+
+export function isVariantPath(
+  variant: SampleVariant,
+): variant is SampleVariantPath {
+  return typeof variant === "string" && fs.existsSync(variant);
+}
+
+export function isVariantReference(
+  variant: SampleVariant,
+): variant is SampleVariantReference {
+  return typeof variant === "string" && !fs.existsSync(variant);
+}

package/test/bach.test.ts

@@ -0,0 +1,285 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import path from "path";
+
+vi.mock("fs");
+import fs from "fs";
+const mockFs = vi.mocked(fs);
+
+vi.mock("@caleuche/core");
+import { compileSample, Sample } from "@caleuche/core";
+const mockCompileSample = vi.mocked(compileSample);
+
+vi.mock("../src/utils");
+import {
+  parse,
+  resolveSampleFile,
+  createOutputDirectory,
+  resolveTemplate,
+  isVariantDefinition,
+  isVariantPath,
+  isVariantReference,
+} from "../src/utils";
+const mockParse = vi.mocked(parse);
+const mockResolveSampleFile = vi.mocked(resolveSampleFile);
+const mockCreateOutputDirectory = vi.mocked(createOutputDirectory);
+const mockResolveTemplate = vi.mocked(resolveTemplate);
+const mockIsVariantDefinition = vi.mocked(isVariantDefinition);
+const mockIsVariantPath = vi.mocked(isVariantPath);
+const mockIsVariantReference = vi.mocked(isVariantReference);
+
+import { batchCompile } from "../src/batch";
+
+describe("batchCompile", () => {
+  let mockExit: any;
+  let mockConsoleError: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
+      throw new Error("process.exit");
+    });
+    mockConsoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should exit if batch file does not exist", () => {
+    mockFs.existsSync.mockReturnValue(false);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      'Batch file "batch.yaml" does not exist.',
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if batch file is not a file", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => false } as any);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      '"batch.yaml" is not a file.',
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if batch file cannot be parsed", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce(null);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      "Failed to parse batch file: batch.yaml",
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if variant definitions cannot be loaded", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse
+      .mockImplementationOnce(() => ({
+        variants: { foo: "badvariant.yaml" },
+        samples: [],
+      }))
+      .mockImplementationOnce(() => null);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      `Failed to load variant definition for key "foo": badvariant.yaml`,
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if sample file not found", () => {
+    mockFs.existsSync.mockReturnValueOnce(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce({
+      variants: {},
+      samples: [{ templatePath: "sample.yaml", variants: [], output: "out" }],
+    });
+    mockResolveSampleFile.mockReturnValue("sample.yaml");
+    mockFs.existsSync.mockReturnValueOnce(false);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      "Sample file not found: sample.yaml",
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if sample file cannot be parsed", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce({
+      variants: {},
+      samples: [
+        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+      ],
+    });
+    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+    mockParse.mockReturnValueOnce(null);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      "Failed to parse sample file: /path/to/sample.yaml",
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if variant cannot be resolved", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce({
+      variants: {},
+      samples: [
+        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+      ],
+    });
+    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+    mockParse.mockReturnValueOnce({
+      template: "t",
+      type: "js",
+      dependencies: [],
+      input: [],
+    });
+    mockResolveTemplate.mockReturnValue("resolved template");
+    // variant resolution fails
+    mockIsVariantPath.mockReturnValue(false);
+    mockIsVariantDefinition.mockReturnValue(false);
+    mockIsVariantReference.mockReturnValue(false);
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith('Invalid variant type: "v1"');
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if compilation throws error", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce({
+      variants: {},
+      samples: [
+        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+      ],
+    });
+    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+    mockParse.mockReturnValueOnce({
+      template: "t",
+      type: "js",
+      dependencies: [],
+      input: [],
+    });
+    mockResolveTemplate.mockReturnValue("resolved template");
+    mockIsVariantPath.mockReturnValue(false);
+    mockIsVariantDefinition.mockReturnValue(true);
+    mockCompileSample.mockImplementation(() => {
+      throw new Error("Compilation error");
+    });
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenNthCalledWith(
+      1,
+      "Error during compilation: Compilation error",
+    );
+    expect(mockConsoleError).toHaveBeenNthCalledWith(
+      2,
+      'Sample: sample.yaml, Variant: "v1"',
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should exit if compilation throws unknown error", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce({
+      variants: {},
+      samples: [
+        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+      ],
+    });
+    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+    mockParse.mockReturnValueOnce({
+      template: "t",
+      type: "js",
+      dependencies: [],
+      input: [],
+    });
+    mockResolveTemplate.mockReturnValue("resolved template");
+    // variant resolution
+    mockIsVariantPath.mockReturnValue(false);
+    mockIsVariantDefinition.mockReturnValue(true);
+    // compileSample throws unknown error
+    mockCompileSample.mockImplementation(() => {
+      throw "Unknown error";
+    });
+    expect(() => {
+      batchCompile("batch.yaml");
+    }).toThrow("process.exit");
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      "An unknown error occurred during compilation.",
+    );
+    expect(mockExit).toHaveBeenCalledWith(1);
+  });
+
+  it("should compile and write output files for each variant", () => {
+    mockFs.existsSync.mockReturnValue(true);
+    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockParse.mockReturnValueOnce({
+      variants: {},
+      samples: [
+        {
+          templatePath: "sample.yaml",
+          variants: [
+            { output: "v1.output", foo: "bar" },
+            { output: "v2.output", foo: "baz" },
+          ],
+          output: "out",
+        },
+      ],
+    });
+    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+    mockParse.mockReturnValueOnce({
+      template: "t",
+      type: "js",
+      dependencies: [],
+      input: [],
+    });
+    mockResolveTemplate.mockReturnValue("resolved template");
+    // variant resolution
+    mockIsVariantPath.mockReturnValue(false);
+    mockIsVariantDefinition.mockReturnValue(true);
+    // compileSample returns output
+    mockCompileSample.mockReturnValue({
+      items: [
+        { fileName: "file1.js", content: "console.log('1');" },
+        { fileName: "file2.js", content: "console.log('2');" },
+      ],
+    });
+    mockCreateOutputDirectory.mockImplementation(() => {});
+    mockFs.writeFileSync.mockImplementation(() => {});
+    batchCompile("batch.yaml");
+    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("v1.output");
+    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("v2.output");
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+      path.join("v1.output", "file1.js"),
+      "console.log('1');",
+    );
+    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+      path.join("v1.output", "file2.js"),
+      "console.log('2');",
+    );
+  });
+});

package/test/common.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import path from "path";
+
+vi.mock("fs");
+import fs from "fs";
+const mockFs = vi.mocked(fs);
+
+vi.mock("@caleuche/core");
+import { compileSample, Sample } from "@caleuche/core";
+const mockCompileSample = vi.mocked(compileSample);
+
+vi.mock("../src/utils");
+import {
+  parse,
+  resolveSampleFile,
+  createOutputDirectory,
+  resolveTemplate,
+  isVariantDefinition,
+  isVariantPath,
+  isVariantReference,
+} from "../src/utils";
+import { resolveAndParseSample } from "../src/common";
+const mockParse = vi.mocked(parse);
+const mockResolveSampleFile = vi.mocked(resolveSampleFile);
+const mockCreateOutputDirectory = vi.mocked(createOutputDirectory);
+const mockResolveTemplate = vi.mocked(resolveTemplate);
+const mockIsVariantDefinition = vi.mocked(isVariantDefinition);
+const mockIsVariantPath = vi.mocked(isVariantPath);
+const mockIsVariantReference = vi.mocked(isVariantReference);
+
+describe("common", () => {
+  describe("resolveAndParseSample", () => {
+    let mockConsoleError: any;
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      mockConsoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      vi.restoreAllMocks();
+    });
+
+    it("should return null and log an error when sample file does not exist", () => {
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(false);
+
+      const sample = resolveAndParseSample("sample");
+      expect(sample).toBeNull();
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Sample file not found: /path/to/sample.yaml",
+      );
+    });
+
+    it("should return null and log an error when sample file cannot be parsed", () => {
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(null);
+
+      const sample = resolveAndParseSample("sample");
+      expect(sample).toBeNull();
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse sample file: /path/to/sample.yaml",
+      );
+    });
+  });
+});

package/test/compile.test.ts

@@ -42,35 +42,6 @@ describe("compile", () => {
   });
 
   describe("error handling", () => {
-    it("should exit when sample file does not exist", () => {
-      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(false);
-
-      expect(() => {
-        compile("sample", "data.json", "output", {});
-      }).toThrow("process.exit");
-
-      expect(mockConsoleError).toHaveBeenCalledWith(
-        "Sample file not found: /path/to/sample.yaml",
-      );
-      expect(mockExit).toHaveBeenCalledWith(1);
-    });
-
-    it("should exit when sample file cannot be parsed", () => {
-      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
-      mockParse.mockReturnValueOnce(null);
-
-      expect(() => {
-        compile("sample", "data.json", "output", {});
-      }).toThrow("process.exit");
-
-      expect(mockConsoleError).toHaveBeenCalledWith(
-        "Failed to parse sample file: /path/to/sample.yaml",
-      );
-      expect(mockExit).toHaveBeenCalledWith(1);
-    });
-
     it("should exit when data file cannot be parsed", () => {
       const mockSample: Sample = {
         template: "test template",