@caleuche/cli 0.2.3 → 0.2.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @caleuche/cli
 
+## 0.2.4
+
+### Patch Changes
+
+- 4e1bb52: Fixing paths and file imports for batch yaml file.
+
 ## 0.2.3
 
 ### Patch Changes

package/dist/batch.js

@@ -8,12 +8,12 @@ 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) {
+function loadVariantDefinition(variant, workingDirectory) {
     if ((0, utils_1.isVariantDefinition)(variant)) {
         return variant;
     }
-    else if ((0, utils_1.isVariantPath)(variant)) {
-        const v = (0, utils_1.parse)(variant);
+    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}`);
             return null;
@@ -22,12 +22,12 @@ function loadVariantDefinition(variant) {
     }
     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);
+        const v = loadVariantDefinition(variant, workingDirectory);
         if (!v) {
             console.error(`Failed to load variant definition for key "${key}": ${variant}`);
             return null;
@@ -36,44 +36,36 @@ function loadVariantDefinitions(variants) {
     }
     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;
-        }
-        return v;
-    }
-    else if ((0, utils_1.isVariantDefinition)(variant.data)) {
+function resolveVariantDefinition(variant, variantRegistry, workingDirectory) {
+    if ((0, utils_1.isVariantDefinition)(variant.data)) {
         return variant.data;
     }
-    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;
+    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 (v) {
+            return v;
         }
+    }
+    const v = variantRegistry[variant.data];
+    if (v) {
         return v;
     }
-    console.error(`Invalid variant type: ${JSON.stringify(variant)}`);
+    console.error(`Variant "${variant.data}" could not be resolved.`);
     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 workingDirectory = (0, utils_1.getAbsoluteDirectoryPath)(batchFile);
+    console.log(`Working directory: ${workingDirectory}`);
     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);
+    const variants = loadVariantDefinitions(bachDefinition.variants, workingDirectory);
     console.log(`Loaded ${Object.keys(variants || {}).length} variant definitions from batch file.`);
     if (!variants) {
         process.exit(1);
@@ -81,18 +73,18 @@ function batchCompile(batchFile) {
     const samples = bachDefinition.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

@@ -10,8 +10,8 @@ exports.createOutputDirectory = createOutputDirectory;
 exports.resolveTemplate = resolveTemplate;
 exports.isObject = isObject;
 exports.isVariantDefinition = isVariantDefinition;
-exports.isVariantPath = isVariantPath;
-exports.isVariantReference = isVariantReference;
+exports.getAbsoluteDirectoryPath = getAbsoluteDirectoryPath;
+exports.isFile = isFile;
 const yaml_1 = require("yaml");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
@@ -60,9 +60,9 @@ function isObject(value) {
 function isVariantDefinition(variant) {
     return isObject(variant) && !Array.isArray(variant);
 }
-function isVariantPath(variant) {
-    return typeof variant === "string" && fs_1.default.existsSync(variant);
+function getAbsoluteDirectoryPath(filePath) {
+    return path_1.default.dirname(path_1.default.resolve(filePath));
 }
-function isVariantReference(variant) {
-    return typeof variant === "string" && !fs_1.default.existsSync(variant);
+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.2.4",
   "main": "dist/index.js",
   "bin": {
     "che": "dist/index.js"

package/src/batch.ts

@@ -1,8 +1,8 @@
 import fs from "fs";
 import {
+  getAbsoluteDirectoryPath,
+  isFile,
   isVariantDefinition,
-  isVariantPath,
-  isVariantReference,
   parse,
 } from "./utils";
 import { compileAndWriteOutput, resolveAndParseSample } from "./common";
@@ -10,11 +10,12 @@ import path from "path";
 
 function loadVariantDefinition(
   variant: SampleVariantDefinition | SampleVariantPath,
+  workingDirectory: string
 ): SampleVariantDefinition | null {
   if (isVariantDefinition(variant)) {
     return variant;
-  } else if (isVariantPath(variant)) {
-    const v = parse<SampleVariantDefinition>(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}`);
       return null;
@@ -25,12 +26,13 @@ function loadVariantDefinition(
 }
 
 function loadVariantDefinitions(
-  variants?: Record<string, SampleVariantDefinition | SampleVariantPath>,
+  variants: Record<string, SampleVariantDefinition | SampleVariantPath> | undefined,
+  workingDirectory: string
 ): Record<string, SampleVariantDefinition> | null {
   if (!variants) return {};
   const definitions: Record<string, SampleVariantDefinition> = {};
   for (const [key, variant] of Object.entries(variants)) {
-    const v = loadVariantDefinition(variant);
+    const v = loadVariantDefinition(variant, workingDirectory);
     if (!v) {
       console.error(
         `Failed to load variant definition for key "${key}": ${variant}`,
@@ -45,45 +47,41 @@ function loadVariantDefinitions(
 function resolveVariantDefinition(
   variant: SampleVariantConfig,
   variantRegistry: Record<string, SampleVariantDefinition>,
+  workingDirectory: string
 ): 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;
-    }
-    return v;
-  } else if (isVariantDefinition(variant.data)) {
+  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;
+  }
+
+  if (isFile(path.join(workingDirectory, variant.data))) {
+    const v = parse<SampleVariantDefinition>(path.join(workingDirectory, variant.data));
+    if (v) {
+      return v;
     }
-    return v;
   }
-  console.error(`Invalid variant type: ${JSON.stringify(variant)}`);
-  return null;
+
+
+    const v = variantRegistry[variant.data];
+    if (v) {
+      return v;
+    }
+    console.error(`Variant "${variant.data}" could not be resolved.`);
+    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 workingDirectory = getAbsoluteDirectoryPath(batchFile);
+  console.log(`Working directory: ${workingDirectory}`);
   const bachDefinition = parse<BatchCompileOptions>(batchFile);
   if (!bachDefinition) {
     console.error(`Failed to parse batch file: ${batchFile}`);
     process.exit(1);
   }
-  const variants = loadVariantDefinitions(bachDefinition.variants);
+  const variants = loadVariantDefinitions(bachDefinition.variants, workingDirectory);
   console.log(
     `Loaded ${Object.keys(variants || {}).length} variant definitions from batch file.`,
   );
@@ -94,7 +92,7 @@ export function batchCompile(batchFile: string) {
   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,13 +102,13 @@ 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),
+        workingDirectory,
         variant.output,
       );
 

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/utils.ts

@@ -58,14 +58,12 @@ export function isVariantDefinition(
   return isObject(variant) && !Array.isArray(variant);
 }
 
-export function isVariantPath(
-  variant: SampleVariant,
-): variant is SampleVariantPath {
-  return typeof variant === "string" && fs.existsSync(variant);
+export function getAbsoluteDirectoryPath(
+  filePath: string,
+): string {
+  return path.dirname(path.resolve(filePath));
 }
 
-export function isVariantReference(
-  variant: SampleVariant,
-): variant is SampleVariantReference {
-  return typeof variant === "string" && !fs.existsSync(variant);
+export function isFile(filePath: string): boolean {
+  return fs.existsSync(filePath) && fs.lstatSync(filePath).isFile();
 }

package/test/bach.test.ts

@@ -16,16 +16,16 @@ import {
   createOutputDirectory,
   resolveTemplate,
   isVariantDefinition,
-  isVariantPath,
-  isVariantReference,
+  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 mockIsVariantPath = vi.mocked(isVariantPath);
-const mockIsVariantReference = vi.mocked(isVariantReference);
+const mockGetAbsoluteDirectoryPath = vi.mocked(getAbsoluteDirectoryPath);
+const mockIsFile = vi.mocked(isFile);
 
 import { batchCompile } from "../src/batch";
 
@@ -51,7 +51,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 +63,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 +76,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);
   });
@@ -94,14 +94,14 @@ 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: {},
       samples: [{ templatePath: "sample.yaml", variants: [], output: "out" }],
@@ -112,7 +112,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);
   });
@@ -124,7 +124,7 @@ describe("batchCompile", () => {
       variants: {},
       samples: [
         { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
-      ],
+      ]
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
     mockParse.mockReturnValueOnce(null);
@@ -132,18 +132,18 @@ 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: {},
       samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+        { templatePath: "sample.yaml", variants: [{ output: "out", data: "v1" }] },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -154,24 +154,26 @@ describe("batchCompile", () => {
       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(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: {},
       samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+        {
+          templatePath: "sample.yaml",
+          variants: [{ output: "out", data: "v1" }],
+        },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -182,7 +184,6 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    mockIsVariantPath.mockReturnValue(false);
     mockIsVariantDefinition.mockReturnValue(true);
     mockCompileSample.mockImplementation(() => {
       throw new Error("Compilation error");
@@ -196,18 +197,21 @@ describe("batchCompile", () => {
     );
     expect(mockConsoleError).toHaveBeenNthCalledWith(
       2,
-      'Sample: sample.yaml, Variant: "v1"',
+      'Sample: sample.yaml, Variant: {"output":"out","data":"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: {},
       samples: [
-        { templatePath: "sample.yaml", variants: ["v1"], output: "out" },
+        {
+          templatePath: "sample.yaml",
+          variants: [{ output: "out", data: "v1" }],
+        },
       ],
     });
     mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
@@ -218,10 +222,7 @@ describe("batchCompile", () => {
       input: [],
     });
     mockResolveTemplate.mockReturnValue("resolved template");
-    // variant resolution
-    mockIsVariantPath.mockReturnValue(false);
     mockIsVariantDefinition.mockReturnValue(true);
-    // compileSample throws unknown error
     mockCompileSample.mockImplementation(() => {
       throw "Unknown error";
     });
@@ -235,16 +236,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: {},
       samples: [
         {
           templatePath: "sample.yaml",
           variants: [
-            { output: "v1.output", foo: "bar" },
-            { output: "v2.output", foo: "baz" },
+            { output: "v1.output", data: {} },
+            { output: "v2.output", data: {} },
           ],
           output: "out",
         },
@@ -258,10 +259,7 @@ describe("batchCompile", () => {
       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');" },
@@ -271,14 +269,14 @@ 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,16 @@ 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,
+  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 +44,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);