@caleuche/cli 0.2.3 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @caleuche/cli
 
+## 0.3.0
+
+### Minor Changes
+
+- ff834ac: Changing batch file schema.
+
+## 0.2.4
+
+### Patch Changes
+
+- 4e1bb52: Fixing paths and file imports for batch yaml file.
+
 ## 0.2.3
 
 ### Patch Changes

package/dist/batch.js

@@ -4,95 +4,100 @@ 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) {
-    if ((0, utils_1.isVariantDefinition)(variant)) {
-        return variant;
+function loadVariantInputDefinition(variantInput, workingDirectory) {
+    if ((0, utils_1.isVariantInputDefinition)(variantInput)) {
+        return variantInput;
     }
-    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}`);
+    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) {
+function loadVariantDefinitions(variants, workingDirectory) {
     if (!variants)
         return {};
     const definitions = {};
-    for (const [key, variant] of Object.entries(variants)) {
-        const v = loadVariantDefinition(variant);
+    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}": ${input}`);
             return null;
         }
-        definitions[key] = v;
+        definitions[name] = v;
     }
     return definitions;
 }
-function resolveVariantDefinition(variant, variantRegistry) {
-    if ((0, utils_1.isVariantPath)(variant.data)) {
-        const v = (0, utils_1.parse)(variant.data);
-        if (!v) {
-            console.error(`Failed to parse variant at path: ${variant}`);
-            return null;
+function resolveVariantDefinition(variant, variantRegistry, workingDirectory) {
+    if ((0, utils_1.isVariantInputReference)(variant.input)) {
+        const ref = (0, utils_1.getVariantInputReferenceValue)(variant.input);
+        const v = variantRegistry[ref];
+        if (v) {
+            return v;
         }
-        return v;
+        console.error(`Variant "${ref}" could not be resolved.`);
+        return null;
     }
-    else if ((0, utils_1.isVariantDefinition)(variant.data)) {
-        return variant.data;
+    else if ((0, utils_1.isVariantInputDefinition)(variant.input)) {
+        return variant.input;
     }
-    else if ((0, utils_1.isVariantReference)(variant.data)) {
-        const v = variantRegistry[variant.data];
-        if (!v) {
-            console.error(`Variant reference "${variant.data}" not found in registry.`);
-            return null;
+    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;
+            }
         }
-        return v;
+        console.error(`Variant input path "${variant.input.value}" does not exist or is not a file.`);
+        return null;
     }
-    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.`);
+    if (!(0, utils_1.isFile)(batchFile)) {
+        console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
         process.exit(1);
     }
-    const bachDefinition = (0, utils_1.parse)(batchFile);
-    if (!bachDefinition) {
+    const workingDirectory = (0, utils_1.getAbsoluteDirectoryPath)(batchFile);
+    console.log(`Working directory: ${workingDirectory}`);
+    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);
+    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(path_1.default.dirname(batchFile), sampleDefinition.templatePath);
+        const templatePath = path_1.default.join(workingDirectory, sampleDefinition.templatePath);
         const sample = (0, common_1.resolveAndParseSample)(templatePath);
         if (!sample) {
             process.exit(1);
         }
         for (const variant of sampleDefinition.variants) {
             console.log("Processing variant...");
-            const resolvedVariant = resolveVariantDefinition(variant, variants);
+            const resolvedVariant = resolveVariantDefinition(variant, variants, workingDirectory);
             if (!resolvedVariant) {
                 process.exit(1);
             }
-            const effectiveOutputPath = path_1.default.join(path_1.default.dirname(batchFile), variant.output);
+            const effectiveOutputPath = path_1.default.join(workingDirectory, variant.output);
             if (!(0, common_1.compileAndWriteOutput)(sample, resolvedVariant, effectiveOutputPath, {
                 project: true,
             })) {

package/dist/common.js

@@ -11,7 +11,7 @@ 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)) {
+    if (!(0, utils_1.isFile)(sampleFilePath)) {
         console.error(`Sample file not found: ${sampleFilePath}`);
         return null;
     }

package/dist/utils.js

@@ -9,9 +9,12 @@ exports.isDirectory = isDirectory;
 exports.createOutputDirectory = createOutputDirectory;
 exports.resolveTemplate = resolveTemplate;
 exports.isObject = isObject;
-exports.isVariantDefinition = isVariantDefinition;
-exports.isVariantPath = isVariantPath;
-exports.isVariantReference = isVariantReference;
+exports.isVariantInputDefinition = isVariantInputDefinition;
+exports.isVariantInputPath = isVariantInputPath;
+exports.isVariantInputReference = isVariantInputReference;
+exports.getVariantInputReferenceValue = getVariantInputReferenceValue;
+exports.getAbsoluteDirectoryPath = getAbsoluteDirectoryPath;
+exports.isFile = isFile;
 const yaml_1 = require("yaml");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -57,12 +60,25 @@ 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 isVariantPath(variant) {
-    return typeof variant === "string" && fs_1.default.existsSync(variant);
+function isVariantInputPath(variant) {
+    return isObject(variant) && variant.type === "path";
 }
-function isVariantReference(variant) {
-    return typeof variant === "string" && !fs_1.default.existsSync(variant);
+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));
+}
+function isFile(filePath) {
+    return fs_1.default.existsSync(filePath) && fs_1.default.lstatSync(filePath).isFile();
 }

package/package.json

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

package/src/batch.ts

@@ -1,100 +1,114 @@
-import fs from "fs";
 import {
-  isVariantDefinition,
-  isVariantPath,
-  isVariantReference,
+  getAbsoluteDirectoryPath,
+  getVariantInputReferenceValue,
+  isFile,
+  isVariantInputDefinition,
+  isVariantInputReference,
   parse,
 } from "./utils";
 import { compileAndWriteOutput, resolveAndParseSample } from "./common";
 import path from "path";
 
-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}`);
+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>,
-): 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);
+  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}`,
+        `Failed to load variant definition for key "${name}": ${input}`,
       );
       return null;
     }
-    definitions[key] = v;
+    definitions[name] = v;
   }
   return definitions;
 }
 
 function resolveVariantDefinition(
   variant: SampleVariantConfig,
-  variantRegistry: Record<string, SampleVariantDefinition>,
-): SampleVariantDefinition | null {
-  if (isVariantPath(variant.data)) {
-    const v = parse<SampleVariantDefinition>(variant.data);
-    if (!v) {
-      console.error(`Failed to parse variant at path: ${variant}`);
-      return null;
+  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;
     }
-    return v;
-  } else if (isVariantDefinition(variant.data)) {
-    return variant.data;
-  } else if (isVariantReference(variant.data)) {
-    const v = variantRegistry[variant.data];
-    if (!v) {
-      console.error(
-        `Variant reference "${variant.data}" not found in registry.`,
-      );
-      return null;
+    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;
+      }
     }
-    return v;
+    console.error(
+      `Variant input path "${variant.input.value}" does not exist or is not a file.`,
+    );
+    return null;
   }
-  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.`);
+  if (!isFile(batchFile)) {
+    console.error(`Batch file "${batchFile}" does not exist or is not a file.`);
     process.exit(1);
   }
-  const bachDefinition = parse<BatchCompileOptions>(batchFile);
-  if (!bachDefinition) {
+  const workingDirectory = getAbsoluteDirectoryPath(batchFile);
+  console.log(`Working directory: ${workingDirectory}`);
+  const batchDefinition = parse<BatchCompileDescription>(batchFile);
+  if (!batchDefinition) {
     console.error(`Failed to parse batch file: ${batchFile}`);
     process.exit(1);
   }
-  const variants = loadVariantDefinitions(bachDefinition.variants);
+  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(
-      path.dirname(batchFile),
+      workingDirectory,
       sampleDefinition.templatePath,
     );
     const sample = resolveAndParseSample(templatePath);
@@ -104,15 +118,16 @@ export function batchCompile(batchFile: string) {
 
     for (const variant of sampleDefinition.variants) {
       console.log("Processing variant...");
-      const resolvedVariant = resolveVariantDefinition(variant, variants);
+      const resolvedVariant = resolveVariantDefinition(
+        variant,
+        variants,
+        workingDirectory,
+      );
       if (!resolvedVariant) {
         process.exit(1);
       }
 
-      const effectiveOutputPath = path.join(
-        path.dirname(batchFile),
-        variant.output,
-      );
+      const effectiveOutputPath = path.join(workingDirectory, variant.output);
 
       if (
         !compileAndWriteOutput(sample, resolvedVariant, effectiveOutputPath, {

package/src/common.ts

@@ -1,6 +1,7 @@
 import { compileSample, Sample } from "@caleuche/core";
 import {
   createOutputDirectory,
+  isFile,
   parse,
   resolveSampleFile,
   resolveTemplate,
@@ -10,7 +11,7 @@ import path from "path";
 
 export function resolveAndParseSample(samplePath: string): Sample | null {
   const sampleFilePath = resolveSampleFile(samplePath);
-  if (!fs.existsSync(sampleFilePath)) {
+  if (!isFile(sampleFilePath)) {
     console.error(`Sample file not found: ${sampleFilePath}`);
     return null;
   }

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

@@ -52,20 +52,40 @@ 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 isVariantPath(
-  variant: SampleVariant,
-): variant is SampleVariantPath {
-  return typeof variant === "string" && fs.existsSync(variant);
+export function isVariantInputPath(
+  variant: SampleVariantInput,
+): variant is SampleVariantInputPath {
+  return isObject(variant) && variant.type === "path";
 }
 
-export function isVariantReference(
-  variant: SampleVariant,
-): variant is SampleVariantReference {
-  return typeof variant === "string" && !fs.existsSync(variant);
+export function isVariantInputReference(
+  variant: SampleVariantInput | string,
+): variant is SampleVariantInputReference | string {
+  return (
+    (isObject(variant) && variant.type === "reference") ||
+    typeof variant === "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));
+}
+
+export function isFile(filePath: string): boolean {
+  return fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
 }

package/test/bach.test.ts

@@ -15,17 +15,23 @@ import {
   resolveSampleFile,
   createOutputDirectory,
   resolveTemplate,
-  isVariantDefinition,
-  isVariantPath,
-  isVariantReference,
+  isVariantInputDefinition,
+  getAbsoluteDirectoryPath,
+  isFile,
+  isVariantInputReference,
+  getVariantInputReferenceValue,
 } 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);
+const mockIsVariantInputReference = vi.mocked(isVariantInputReference);
+const mockGetVariantInputReferenceValue = vi.mocked(
+  getVariantInputReferenceValue,
+);
+const mockIsVariantInputDefinition = vi.mocked(isVariantInputDefinition);
+const mockGetAbsoluteDirectoryPath = vi.mocked(getAbsoluteDirectoryPath);
+const mockIsFile = vi.mocked(isFile);
 
 import { batchCompile } from "../src/batch";
 
@@ -51,7 +57,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      'Batch file "batch.yaml" does not exist.',
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -63,7 +69,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      '"batch.yaml" is not a file.',
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -76,7 +82,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Failed to parse batch file: batch.yaml",
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -86,7 +92,9 @@ describe("batchCompile", () => {
     mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
     mockParse
       .mockImplementationOnce(() => ({
-        variants: { foo: "badvariant.yaml" },
+        variants: [
+          { name: "foo", input: { type: "path", value: "badvariant.yaml" } },
+        ],
         samples: [],
       }))
       .mockImplementationOnce(() => null);
@@ -94,16 +102,16 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      `Failed to load variant definition for key "foo": badvariant.yaml`,
+      `Batch file \"batch.yaml\" does not exist or is not a file.`,
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if sample file not found", () => {
-    mockFs.existsSync.mockReturnValueOnce(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockIsFile.mockReturnValue(true);
+    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [{ templatePath: "sample.yaml", variants: [], output: "out" }],
     });
     mockResolveSampleFile.mockReturnValue("sample.yaml");
@@ -112,7 +120,7 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Sample file not found: sample.yaml",
+      "Failed to parse sample file: sample.yaml",
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
@@ -121,7 +129,7 @@ describe("batchCompile", () => {
     mockFs.existsSync.mockReturnValue(true);
     mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
         { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
       ],
@@ -132,18 +140,21 @@ describe("batchCompile", () => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
     expect(mockConsoleError).toHaveBeenCalledWith(
-      "Failed to parse sample file: /path/to/sample.yaml",
+      'Batch file "batch.yaml" does not exist or is not a file.',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if variant cannot be resolved", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockIsFile.mockReturnValue(true);
+    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+        {
+          templatePath: "sample.yaml",
+          variants: [{ output: "out", input: "v1" }],
+        },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -154,24 +165,28 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    // variant resolution fails
-    mockIsVariantPath.mockReturnValue(false);
-    mockIsVariantDefinition.mockReturnValue(false);
-    mockIsVariantReference.mockReturnValue(false);
+    mockIsVariantInputReference.mockReturnValue(true);
+    mockGetVariantInputReferenceValue.mockReturnValue("v1");
+    mockIsVariantInputDefinition.mockReturnValue(false);
     expect(() => {
       batchCompile("batch.yaml");
     }).toThrow("process.exit");
-    expect(mockConsoleError).toHaveBeenCalledWith('Invalid variant type: "v1"');
+    expect(mockConsoleError).toHaveBeenCalledWith(
+      `Variant "v1" could not be resolved.`,
+    );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if compilation throws error", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockIsFile.mockReturnValue(true);
+    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+        {
+          templatePath: "sample.yaml",
+          variants: [{ output: "out", input: "v1" }],
+        },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -182,8 +197,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantPath.mockReturnValue(false);
-    mockIsVariantDefinition.mockReturnValue(true);
+    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw new Error("Compilation error");
     });
@@ -196,18 +210,21 @@ describe("batchCompile", () => {
     );
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       2,
-      'Sample: sample.yaml, Variant: "v1"',
+      'Sample: sample.yaml, Variant: {"output":"out","input":"v1"}',
     );
     expect(mockExit).toHaveBeenCalledWith(1);
   });
 
   it("should exit if compilation throws unknown error", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockIsFile.mockReturnValue(true);
+    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+        {
+          templatePath: "sample.yaml",
+          variants: [{ output: "out", input: "v1" }],
+        },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -218,10 +235,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    // variant resolution
-    mockIsVariantPath.mockReturnValue(false);
-    mockIsVariantDefinition.mockReturnValue(true);
-    // compileSample throws unknown error
+    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw "Unknown error";
     });
@@ -235,16 +249,16 @@ describe("batchCompile", () => {
   });
 
   it("should compile and write output files for each variant", () => {
-    mockFs.existsSync.mockReturnValue(true);
-    mockFs.lstatSync.mockReturnValue({ isFile: () => true } as any);
+    mockIsFile.mockReturnValue(true);
+    mockGetAbsoluteDirectoryPath.mockReturnValue("/working/directory");
     mockParse.mockReturnValueOnce({
-      variants: {},
+      variants: [],
       samples: [
         {
           templatePath: "sample.yaml",
           variants: [
-            { output: "v1.output", foo: "bar" },
-            { output: "v2.output", foo: "baz" },
+            { output: "v1.output", input: {} },
+            { output: "v2.output", input: {} },
           ],
           output: "out",
         },
@@ -258,10 +272,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    // variant resolution
-    mockIsVariantPath.mockReturnValue(false);
-    mockIsVariantDefinition.mockReturnValue(true);
-    // compileSample returns output
+    mockIsVariantInputDefinition.mockReturnValue(true);
     mockCompileSample.mockReturnValue({
       items: [
         { fileName: "file1.js", content: "console.log('1');" },
@@ -271,14 +282,18 @@ describe("batchCompile", () => {
     mockCreateOutputDirectory.mockImplementation(() => {});
     mockFs.writeFileSync.mockImplementation(() => {});
     batchCompile("batch.yaml");
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("v1.output");
-    expect(mockCreateOutputDirectory).toHaveBeenCalledWith("v2.output");
+    expect(mockCreateOutputDirectory).toHaveBeenCalledWith(
+      "/working/directory/v1.output",
+    );
+    expect(mockCreateOutputDirectory).toHaveBeenCalledWith(
+      "/working/directory/v2.output",
+    );
     expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-      path.join("v1.output", "file1.js"),
+      path.join("/working/directory", "v1.output", "file1.js"),
       "console.log('1');",
     );
     expect(mockFs.writeFileSync).toHaveBeenCalledWith(
-      path.join("v1.output", "file2.js"),
+      path.join("/working/directory", "v1.output", "file2.js"),
       "console.log('2');",
     );
   });

package/test/common.test.ts

@@ -5,28 +5,12 @@ 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 { parse, resolveSampleFile, isFile } 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);
+const mockIsFile = vi.mocked(isFile);
 
 describe("common", () => {
   describe("resolveAndParseSample", () => {
@@ -56,7 +40,7 @@ describe("common", () => {
 
     it("should return null and log an error when sample file cannot be parsed", () => {
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(null);
 
       const sample = resolveAndParseSample("sample");

package/test/compile.test.ts

@@ -16,12 +16,14 @@ import {
   createOutputDirectory,
   resolveTemplate,
   isObject,
+  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 mockIsObject = vi.mocked(isObject);
+const mockIsFile = vi.mocked(isFile);
 
 import { compile } from "../src/compile";
 
@@ -51,7 +53,7 @@ describe("compile", () => {
       };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce(null);
@@ -75,7 +77,7 @@ describe("compile", () => {
       };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce("not an object");
@@ -101,7 +103,7 @@ describe("compile", () => {
       const mockData = { name: "test" };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce(mockData);
@@ -130,7 +132,7 @@ describe("compile", () => {
       const mockData = { name: "test" };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce(mockData);
@@ -167,7 +169,7 @@ describe("compile", () => {
       };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce(mockData);
@@ -203,7 +205,7 @@ describe("compile", () => {
       };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce(mockData);
@@ -234,7 +236,7 @@ describe("compile", () => {
       };
 
       mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
-      mockFs.existsSync.mockReturnValue(true);
+      mockIsFile.mockReturnValue(true);
       mockParse.mockReturnValueOnce(mockSample);
       mockResolveTemplate.mockReturnValue("resolved template");
       mockParse.mockReturnValueOnce(mockData);