@caleuche/cli 0.2.4 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @caleuche/cli
 
+## 0.4.0
+
+### Minor Changes
+
+- 566dad9: Updated command help strings.
+- 6215af4: Adding option directory to batch command.
+
+## 0.3.0
+
+### Minor Changes
+
+- ff834ac: Changing batch file schema.
+
 ## 0.2.4
 
 ### Patch Changes

package/dist/batch.js

@@ -4,73 +4,86 @@ var __importDefault = (this && this.__importDefault) || function (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");
 const path_1 = __importDefault(require("path"));
-function loadVariantDefinition(variant, workingDirectory) {
-    if ((0, utils_1.isVariantDefinition)(variant)) {
-        return variant;
+function loadVariantInputDefinition(variantInput, workingDirectory) {
+    if ((0, utils_1.isVariantInputDefinition)(variantInput)) {
+        return variantInput;
     }
-    else if (fs_1.default.existsSync(path_1.default.join(workingDirectory, variant))) {
-        const v = (0, utils_1.parse)(path_1.default.join(workingDirectory, variant));
-        if (!v) {
-            console.error(`Failed to parse variant at path: ${variant}`);
+    else {
+        const absolutePath = path_1.default.join(workingDirectory, variantInput.value);
+        if ((0, utils_1.isFile)(absolutePath)) {
+            const v = (0, utils_1.parse)(absolutePath);
+            if (!v) {
+                console.error(`Failed to parse variant at path: ${absolutePath}`);
+                return null;
+            }
+            return v;
+        }
+        else {
+            console.error(`Variant input path "${variantInput.value}" does not exist or is not a file.`);
             return null;
         }
-        return v;
     }
-    return null;
 }
 function loadVariantDefinitions(variants, workingDirectory) {
     if (!variants)
         return {};
     const definitions = {};
-    for (const [key, variant] of Object.entries(variants)) {
-        const v = loadVariantDefinition(variant, workingDirectory);
+    for (const { name, input } of variants) {
+        const v = loadVariantInputDefinition(input, workingDirectory);
         if (!v) {
-            console.error(`Failed to load variant definition for key "${key}": ${variant}`);
+            console.error(`Failed to load variant definition for key "${name}"`);
             return null;
         }
-        definitions[key] = v;
+        definitions[name] = v;
     }
     return definitions;
 }
 function resolveVariantDefinition(variant, variantRegistry, workingDirectory) {
-    if ((0, utils_1.isVariantDefinition)(variant.data)) {
-        return variant.data;
-    }
-    if ((0, utils_1.isFile)(path_1.default.join(workingDirectory, variant.data))) {
-        const v = (0, utils_1.parse)(path_1.default.join(workingDirectory, variant.data));
+    if ((0, utils_1.isVariantInputReference)(variant.input)) {
+        const ref = (0, utils_1.getVariantInputReferenceValue)(variant.input);
+        const v = variantRegistry[ref];
         if (v) {
             return v;
         }
+        console.error(`Variant "${ref}" could not be resolved.`);
+        return null;
+    }
+    else if ((0, utils_1.isVariantInputDefinition)(variant.input)) {
+        return variant.input;
     }
-    const v = variantRegistry[variant.data];
-    if (v) {
-        return v;
+    else {
+        const absolutePath = path_1.default.join(workingDirectory, variant.input.value);
+        if ((0, utils_1.isFile)(absolutePath)) {
+            const v = (0, utils_1.parse)(absolutePath);
+            if (v) {
+                return v;
+            }
+        }
+        console.error(`Variant input path "${variant.input.value}" does not exist or is not a file.`);
+        return null;
     }
-    console.error(`Variant "${variant.data}" could not be resolved.`);
-    return null;
 }
-function batchCompile(batchFile) {
+function batchCompile(batchFile, options) {
     if (!(0, utils_1.isFile)(batchFile)) {
         console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
         process.exit(1);
     }
     const workingDirectory = (0, utils_1.getAbsoluteDirectoryPath)(batchFile);
     console.log(`Working directory: ${workingDirectory}`);
-    const bachDefinition = (0, utils_1.parse)(batchFile);
-    if (!bachDefinition) {
+    const batchDefinition = (0, utils_1.parse)(batchFile);
+    if (!batchDefinition) {
         console.error(`Failed to parse batch file: ${batchFile}`);
         process.exit(1);
     }
-    const variants = loadVariantDefinitions(bachDefinition.variants, workingDirectory);
+    const variants = loadVariantDefinitions(batchDefinition.variants, workingDirectory);
     console.log(`Loaded ${Object.keys(variants || {}).length} variant definitions from batch file.`);
     if (!variants) {
         process.exit(1);
     }
-    const samples = bachDefinition.samples;
+    const samples = batchDefinition.samples;
     for (const sampleDefinition of samples) {
         console.log(`Processing sample: ${sampleDefinition.templatePath}`);
         const templatePath = path_1.default.join(workingDirectory, sampleDefinition.templatePath);
@@ -84,8 +97,8 @@ function batchCompile(batchFile) {
             if (!resolvedVariant) {
                 process.exit(1);
             }
-            const effectiveOutputPath = path_1.default.join(workingDirectory, variant.output);
-            if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant, effectiveOutputPath, {
+            const effectiveOutputPath = path_1.default.join(options?.outputDir || workingDirectory, variant.output);
+            if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant.properties, effectiveOutputPath, {
                 project: true,
             })) {
                 console.error(`Sample: ${sampleDefinition.templatePath}, Variant: ${JSON.stringify(variant)}`);

package/dist/index.js

@@ -10,8 +10,15 @@ commander_1.program
     .description("Caleuche CLI for compiling samples")
     .version(package_json_1.version);
 commander_1.program
-    .command("compile <sample-directory> <data-file> <output-directory>")
-    .option("-p, --project", "Generate project file")
+    .command("compile")
+    .argument("<sample-path>", "Path to the sample file or the directory that containes it.")
+    .argument("<data-file>", "Path to the input to be used to compile the template.")
+    .argument("<output-directory>", "Directory where the compiled output will be written.")
+    .option("-p, --project", "Flag to indicate whether to generate the appropriate project file along with the compiled template.")
     .action(compile_1.compile);
-commander_1.program.command("batch <batch-file>").action(batch_1.batchCompile);
+commander_1.program
+    .command("batch")
+    .argument("<batch-file>", "Path to the batch file")
+    .option("-d, --output-dir <outputDir>", "Output directory for compiled samples")
+    .action(batch_1.batchCompile);
 commander_1.program.parse();

package/dist/utils.js

@@ -9,7 +9,10 @@ exports.isDirectory = isDirectory;
 exports.createOutputDirectory = createOutputDirectory;
 exports.resolveTemplate = resolveTemplate;
 exports.isObject = isObject;
-exports.isVariantDefinition = isVariantDefinition;
+exports.isVariantInputDefinition = isVariantInputDefinition;
+exports.isVariantInputPath = isVariantInputPath;
+exports.isVariantInputReference = isVariantInputReference;
+exports.getVariantInputReferenceValue = getVariantInputReferenceValue;
 exports.getAbsoluteDirectoryPath = getAbsoluteDirectoryPath;
 exports.isFile = isFile;
 const yaml_1 = require("yaml");
@@ -57,8 +60,21 @@ function resolveTemplate(samplePath, sample) {
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isVariantDefinition(variant) {
-    return isObject(variant) && !Array.isArray(variant);
+function isVariantInputDefinition(variant) {
+    return isObject(variant) && variant.type === "object";
+}
+function isVariantInputPath(variant) {
+    return isObject(variant) && variant.type === "path";
+}
+function isVariantInputReference(variant) {
+    return ((isObject(variant) && variant.type === "reference") ||
+        typeof variant === "string");
+}
+function getVariantInputReferenceValue(variant) {
+    if (typeof variant === "string") {
+        return variant;
+    }
+    return variant.value;
 }
 function getAbsoluteDirectoryPath(filePath) {
     return path_1.default.dirname(path_1.default.resolve(filePath));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@caleuche/cli",
-  "version": "0.2.4",
+  "version": "0.4.0",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"

package/src/batch.ts

@@ -1,94 +1,108 @@
-import fs from "fs";
 import {
   getAbsoluteDirectoryPath,
+  getVariantInputReferenceValue,
   isFile,
-  isVariantDefinition,
+  isVariantInputDefinition,
+  isVariantInputReference,
   parse,
 } from "./utils";
 import { compileAndWriteOutput, resolveAndParseSample } from "./common";
 import path from "path";
 
-function loadVariantDefinition(
-  variant: SampleVariantDefinition | SampleVariantPath,
-  workingDirectory: string
-): SampleVariantDefinition | null {
-  if (isVariantDefinition(variant)) {
-    return variant;
-  } else if (fs.existsSync(path.join(workingDirectory, variant))) {
-    const v = parse<SampleVariantDefinition>(path.join(workingDirectory, variant));
-    if (!v) {
-      console.error(`Failed to parse variant at path: ${variant}`);
+function loadVariantInputDefinition(
+  variantInput: SampleVariantInputDefinition | SampleVariantInputPath,
+  workingDirectory: string,
+): SampleVariantInputDefinition | null {
+  if (isVariantInputDefinition(variantInput)) {
+    return variantInput;
+  } else {
+    const absolutePath = path.join(workingDirectory, variantInput.value);
+    if (isFile(absolutePath)) {
+      const v = parse<SampleVariantInputDefinition>(absolutePath);
+      if (!v) {
+        console.error(`Failed to parse variant at path: ${absolutePath}`);
+        return null;
+      }
+      return v;
+    } else {
+      console.error(
+        `Variant input path "${variantInput.value}" does not exist or is not a file.`,
+      );
       return null;
     }
-    return v;
   }
-  return null;
 }
 
 function loadVariantDefinitions(
-  variants: Record<string, SampleVariantDefinition | SampleVariantPath> | undefined,
-  workingDirectory: string
-): Record<string, SampleVariantDefinition> | null {
+  variants: SampleVariantInputEntry[] | undefined,
+  workingDirectory: string,
+): Record<string, SampleVariantInputDefinition> | null {
   if (!variants) return {};
-  const definitions: Record<string, SampleVariantDefinition> = {};
-  for (const [key, variant] of Object.entries(variants)) {
-    const v = loadVariantDefinition(variant, workingDirectory);
+  const definitions: Record<string, SampleVariantInputDefinition> = {};
+  for (const { name, input } of variants) {
+    const v = loadVariantInputDefinition(input, workingDirectory);
     if (!v) {
-      console.error(
-        `Failed to load variant definition for key "${key}": ${variant}`,
-      );
+      console.error(`Failed to load variant definition for key "${name}"`);
       return null;
     }
-    definitions[key] = v;
+    definitions[name] = v;
   }
   return definitions;
 }
 
 function resolveVariantDefinition(
   variant: SampleVariantConfig,
-  variantRegistry: Record<string, SampleVariantDefinition>,
-  workingDirectory: string
-): SampleVariantDefinition | null {
-  if (isVariantDefinition(variant.data)) {
-    return variant.data;
-  }
-
-  if (isFile(path.join(workingDirectory, variant.data))) {
-    const v = parse<SampleVariantDefinition>(path.join(workingDirectory, variant.data));
+  variantRegistry: Record<string, SampleVariantInputDefinition>,
+  workingDirectory: string,
+): SampleVariantInputDefinition | null {
+  if (isVariantInputReference(variant.input)) {
+    const ref = getVariantInputReferenceValue(variant.input);
+    const v = variantRegistry[ref];
     if (v) {
       return v;
     }
-  }
-
-
-    const v = variantRegistry[variant.data];
-    if (v) {
-      return v;
+    console.error(`Variant "${ref}" could not be resolved.`);
+    return null;
+  } else if (isVariantInputDefinition(variant.input)) {
+    return variant.input;
+  } else {
+    const absolutePath = path.join(workingDirectory, variant.input.value);
+    if (isFile(absolutePath)) {
+      const v = parse<SampleVariantInputDefinition>(absolutePath);
+      if (v) {
+        return v;
+      }
     }
-    console.error(`Variant "${variant.data}" could not be resolved.`);
-    return null
+    console.error(
+      `Variant input path "${variant.input.value}" does not exist or is not a file.`,
+    );
+    return null;
+  }
 }
 
-export function batchCompile(batchFile: string) {
+export function batchCompile(batchFile: string, options: { outputDir?: string }) {
   if (!isFile(batchFile)) {
     console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
     process.exit(1);
   }
   const workingDirectory = getAbsoluteDirectoryPath(batchFile);
   console.log(`Working directory: ${workingDirectory}`);
-  const bachDefinition = parse<BatchCompileOptions>(batchFile);
-  if (!bachDefinition) {
+  const batchDefinition = parse<BatchCompileDescription>(batchFile);
+  if (!batchDefinition) {
     console.error(`Failed to parse batch file: ${batchFile}`);
     process.exit(1);
   }
-  const variants = loadVariantDefinitions(bachDefinition.variants, workingDirectory);
+  const variants = loadVariantDefinitions(
+    batchDefinition.variants,
+    workingDirectory,
+  );
   console.log(
     `Loaded ${Object.keys(variants || {}).length} variant definitions from batch file.`,
   );
   if (!variants) {
     process.exit(1);
   }
-  const samples = bachDefinition.samples;
+  const samples = batchDefinition.samples;
   for (const sampleDefinition of samples) {
     console.log(`Processing sample: ${sampleDefinition.templatePath}`);
     const templatePath = path.join(
@@ -102,18 +116,21 @@ export function batchCompile(batchFile: string) {
 
     for (const variant of sampleDefinition.variants) {
       console.log("Processing variant...");
-      const resolvedVariant = resolveVariantDefinition(variant, variants, workingDirectory);
+      const resolvedVariant = resolveVariantDefinition(
+        variant,
+        variants,
+        workingDirectory,
+      );
       if (!resolvedVariant) {
         process.exit(1);
       }
 
       const effectiveOutputPath = path.join(
-        workingDirectory,
-        variant.output,
-      );
+        options?.outputDir || workingDirectory,
+        variant.output);
 
       if (
-        !compileAndWriteOutput(sample, resolvedVariant, effectiveOutputPath, {
+        !compileAndWriteOutput(sample, resolvedVariant.properties, effectiveOutputPath, {
           project: true,
         })
       ) {

package/src/index.ts

@@ -11,10 +11,17 @@ program
   .version(version);
 
 program
-  .command("compile <sample-directory> <data-file> <output-directory>")
-  .option("-p, --project", "Generate project file")
+  .command("compile")
+  .argument("<sample-path>", "Path to the sample file or the directory that containes it.")
+  .argument("<data-file>", "Path to the input to be used to compile the template.")
+  .argument("<output-directory>", "Directory where the compiled output will be written.")
+  .option("-p, --project", "Flag to indicate whether to generate the appropriate project file along with the compiled template.")
   .action(compile);
 
-program.command("batch <batch-file>").action(batchCompile);
+program
+  .command("batch")
+  .argument("<batch-file>", "Path to the batch file")
+  .option("-d, --output-dir <outputDir>", "Output directory for compiled samples")
+  .action(batchCompile);
 
 program.parse();

package/src/interfaces.ts

@@ -1,14 +1,26 @@
-type SampleVariantDefinition = Record<string, any>;
-type SampleVariantReference = string;
-type SampleVariantPath = string;
-type SampleVariant =
-  | SampleVariantDefinition
-  | SampleVariantReference
-  | SampleVariantPath;
+interface SampleVariantInputDefinition {
+  type: "object";
+  properties: Record<string, any>;
+}
+
+interface SampleVariantInputReference {
+  type: "reference";
+  value: string;
+}
+
+interface SampleVariantInputPath {
+  type: "path";
+  value: string;
+}
+
+type SampleVariantInput =
+  | SampleVariantInputDefinition
+  | SampleVariantInputReference
+  | SampleVariantInputPath;
 
 interface SampleVariantConfig {
   output: string;
-  data: SampleVariant;
+  input: SampleVariantInput | string;
 }
 
 interface SampleDefinition {
@@ -16,7 +28,12 @@ interface SampleDefinition {
   variants: SampleVariantConfig[];
 }
 
-interface BatchCompileOptions {
-  variants?: Record<string, SampleVariantDefinition | SampleVariantPath>;
+interface SampleVariantInputEntry {
+  name: string;
+  input: SampleVariantInputDefinition | SampleVariantInputPath;
+}
+
+interface BatchCompileDescription {
+  variants?: SampleVariantInputEntry[];
   samples: SampleDefinition[];
 }

package/src/utils.ts

@@ -3,6 +3,8 @@ import fs from "fs";
 import path from "path";
 import { Sample } from "@caleuche/core";
 
+export type Optional<T> = T | undefined;
+
 export function parse<T>(filePath: string): T | null {
   try {
     const fileContent = fs.readFileSync(filePath, "utf-8");
@@ -52,15 +54,37 @@ 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 isVariantInputDefinition(
+  variant: SampleVariantInput,
+): variant is SampleVariantInputDefinition {
+  return isObject(variant) && variant.type === "object";
+}
+
+export function isVariantInputPath(
+  variant: SampleVariantInput,
+): variant is SampleVariantInputPath {
+  return isObject(variant) && variant.type === "path";
+}
+
+export function isVariantInputReference(
+  variant: SampleVariantInput | string,
+): variant is SampleVariantInputReference | string {
+  return (
+    (isObject(variant) && variant.type === "reference") ||
+    typeof variant === "string"
+  );
 }
 
-export function getAbsoluteDirectoryPath(
-  filePath: string,
+export function getVariantInputReferenceValue(
+  variant: SampleVariantInputReference | string,
 ): string {
+  if (typeof variant === "string") {
+    return variant;
+  }
+  return variant.value;
+}
+
+export function getAbsoluteDirectoryPath(filePath: string): string {
   return path.dirname(path.resolve(filePath));
 }
 

package/test/bach.test.ts

@@ -1,40 +1,23 @@
 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);
+import path from "path";
+import os from "os";
 
 vi.mock("@caleuche/core");
-import { compileSample, Sample } from "@caleuche/core";
+import { compileSample } from "@caleuche/core";
 const mockCompileSample = vi.mocked(compileSample);
 
-vi.mock("../src/utils");
-import {
-  parse,
-  resolveSampleFile,
-  createOutputDirectory,
-  resolveTemplate,
-  isVariantDefinition,
-  getAbsoluteDirectoryPath,
-  isFile,
-} 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 mockGetAbsoluteDirectoryPath = vi.mocked(getAbsoluteDirectoryPath);
-const mockIsFile = vi.mocked(isFile);
-
 import { batchCompile } from "../src/batch";
+import { Optional } from "../src/utils";
+import { multiline } from "./utils.test";
 
 describe("batchCompile", () => {
+  let tempDir: Optional<string>;
   let mockExit: any;
   let mockConsoleError: any;
 
   beforeEach(() => {
-    vi.clearAllMocks();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "caleuche-cli-test-"));
     mockExit = vi.spyOn(process, "exit").mockImplementation(() => {
       throw new Error("process.exit");
     });
@@ -42,154 +25,193 @@ describe("batchCompile", () => {
   });
 
   afterEach(() => {
+    if (tempDir) {
+      fs.rmSync(tempDir, { recursive: true });
+    }
     vi.restoreAllMocks();
   });
 
+  function getPath(relative: string): string {
+    return path.join(tempDir!, relative);
+  }
+
   it("should exit if batch file does not exist", () => {
-    mockFs.existsSync.mockReturnValue(false);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(getPath("batch.yaml"), {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      `Batch file "${getPath("batch.yaml")}" does not exist or is not a file.`,
     );
     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);
+    fs.mkdirSync(getPath("batch.yaml"));
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile("batch.yaml", {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      'Batch file "batch.yaml" does not exist or 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);
+    const batchFilePath = getPath("batch.yaml");
+    const invalidYaml = multiline`
+      invalid: yaml: structure:
+        broken
+    `;
+    fs.writeFileSync(batchFilePath, invalidYaml);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      `Failed to parse batch file: ${batchFilePath}`,
     );
     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);
+    const batchFilePath = getPath("batch.yaml");
+    const content = multiline`
+      variants:
+        - name: foo
+          input:
+            type: path
+            value: badvariant.yaml
+    `;
+    fs.writeFileSync(batchFilePath, content);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      `Batch file \"batch.yaml\" does not exist or is not a file.`,
+      `Failed to load variant definition for key "foo"`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if sample file not found", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: {},
-      samples: [{ templatePath: "sample.yaml", variants: [], output: "out" }],
-    });
-    mockResolveSampleFile.mockReturnValue("sample.yaml");
-    mockFs.existsSync.mockReturnValueOnce(false);
+    const batchFilePath = getPath("batch.yaml");
+    const content = multiline`
+      samples:
+        - templatePath: sample.yaml
+          variants: []
+          output: out
+    `;
+    fs.writeFileSync(batchFilePath, content);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Failed to parse sample file: sample.yaml",
+      `Sample file not found: ${getPath("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);
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const invalidSampleContent = multiline`
+      some: invalid: yaml
+    `;
+    fs.writeFileSync(sampleFilePath, invalidSampleContent);
+
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Batch file \"batch.yaml\" does not exist or is not a file.",
+      `Failed to parse sample file: ${sampleFilePath}`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if variant cannot be resolved", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: {},
-      samples: [
-        { templatePath: "sample.yaml", variants: [{ output: "out", data: "v1" }] },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(false);
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: bar
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      `Variant "v1" could not be resolved.`,
+      `Variant "bar" could not be resolved.`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if compilation throws error", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: {},
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [{ output: "out", data: "v1" }],
-        },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw new Error("Compilation error");
     });
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(batchFilePath, {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       1,
@@ -197,37 +219,43 @@ describe("batchCompile", () => {
     );
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       2,
-      'Sample: sample.yaml, Variant: {"output":"out","data":"v1"}',
+      'Sample: sample.yaml, Variant: {"output":"out","input":"foo"}',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if compilation throws unknown error", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: {},
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [{ output: "out", data: "v1" }],
-        },
-      ],
-    });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw "Unknown error";
     });
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
     expect(() => {
-      batchCompile("batch.yaml");
+      batchCompile(getPath("batch.yaml"), {});
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
       "An unknown error occurred during compilation.",
@@ -236,47 +264,91 @@ describe("batchCompile", () => {
   });
 
   it("should compile and write output files for each variant", () => {
-    mockIsFile.mockReturnValue(true);
-    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
-    mockParse.mockReturnValueOnce({
-      variants: {},
-      samples: [
-        {
-          templatePath: "sample.yaml",
-          variants: [
-            { output: "v1.output", data: {} },
-            { output: "v2.output", data: {} },
-          ],
-          output: "out",
-        },
+    mockCompileSample.mockReturnValue({
+      items: [
+        { fileName: "file1.js", content: "console.log('1');" },
+        { fileName: "file2.js", content: "console.log('2');" },
       ],
     });
-    mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-    mockParse.mockReturnValueOnce({
-      template: "t",
-      type: "js",
-      dependencies: [],
-      input: [],
-    });
-    mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantDefinition.mockReturnValue(true);
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
+    batchCompile(batchFilePath, {});
+
+    expect(fs.existsSync(getPath("out/file1.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("out/file1.js"), "utf-8")).toBe(
+      "console.log('1');",
+    );
+    expect(fs.existsSync(getPath("out/file2.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("out/file2.js"), "utf-8")).toBe(
+      "console.log('2');",
+    );
+  });
+
+  it("should compile and write output files for each variant", () => {
     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("/working/directory/v1.output");
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("/working/directory/v2.output");
-    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-      path.join("/working/directory", "v1.output", "file1.js"),
+    const batchFilePath = getPath("batch.yaml");
+    const batchFileContent = multiline`
+      variants:
+        - name: foo
+          input:
+            type: object
+            properties:
+              var2: value
+      samples:
+        - templatePath: sample.yaml
+          variants:
+            - output: out
+              input: foo
+    `;
+    fs.writeFileSync(batchFilePath, batchFileContent);
+    const sampleFilePath = getPath("sample.yaml");
+    const sampleContent = multiline`
+      template: sample.js.template
+      type: javascript
+      dependencies:
+      input:
+        - name: var
+          type: string
+          required: true
+    `;
+    fs.writeFileSync(sampleFilePath, sampleContent);
+    batchCompile(batchFilePath, { outputDir: getPath("other") });
+
+    expect(fs.existsSync(getPath("other/out/file1.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("other/out/file1.js"), "utf-8")).toBe(
       "console.log('1');",
     );
-    expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-      path.join("/working/directory", "v1.output", "file2.js"),
+    expect(fs.existsSync(getPath("other/out/file2.js"))).toBe(true);
+    expect(fs.readFileSync(getPath("other/out/file2.js"), "utf-8")).toBe(
       "console.log('2');",
     );
   });

package/test/common.test.ts

@@ -6,11 +6,7 @@ import fs from "fs";
 const mockFs = vi.mocked(fs);
 
 vi.mock("../src/utils");
-import {
-  parse,
-  resolveSampleFile,
-  isFile,
-} from "../src/utils";
+import { parse, resolveSampleFile, isFile } from "../src/utils";
 import { resolveAndParseSample } from "../src/common";
 const mockParse = vi.mocked(parse);
 const mockResolveSampleFile = vi.mocked(resolveSampleFile);

package/test/utils.test.ts

@@ -12,7 +12,7 @@ import {
 } from "../src/utils";
 import { Sample } from "@caleuche/core";
 
-function multiline(strings: TemplateStringsArray, ...values: any[]) {
+export function multiline(strings: TemplateStringsArray, ...values: any[]) {
   let result = strings[0];
   for (let i = 0; i < values.length; i++) {
     result += values[i] + strings[i + 1];