@caleuche/cli 0.1.3 → 0.2.0

package/src/common.ts

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

package/src/compile.ts

@@ -0,0 +1,24 @@
+import { isObject, parse } from "./utils";
+import { compileAndWriteOutput, resolveAndParseSample } from "./common";
+
+export function compile(
+  samplePath: string,
+  dataPath: string,
+  outputPath: string,
+  options: { project?: boolean },
+) {
+  const sample = resolveAndParseSample(samplePath);
+  if (!sample) {
+    return process.exit(1);
+  }
+
+  const inputData = parse<Record<string, any>>(dataPath);
+  if (!inputData || !isObject(inputData)) {
+    console.error(`Failed to parse input data file: ${dataPath}`);
+    process.exit(1);
+  }
+
+  if (!compileAndWriteOutput(sample, inputData, outputPath, options)) {
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -1,67 +1,21 @@
-#!/usr/bin/env node
-
-import { program } from "commander";
-import { compileSample, Sample } from "@caleuche/core";
-import fs from "fs";
-import path from "path";
-import {
-  createOutputDirectory,
-  isObject,
-  parse,
-  resolveSampleFile,
-  resolveTemplate,
-} from "./utils";
-
-program
-  .name("@caleuche/cli")
-  .description("Caleuche CLI for compiling samples")
-  .version("1.0.0");
-
-function compile(
-  samplePath: string,
-  dataPath: string,
-  outputPath: string,
-  options: { project?: boolean },
-) {
-  const sampleFilePath = resolveSampleFile(samplePath);
-  if (!fs.existsSync(sampleFilePath)) {
-    console.error(`Sample file not found: ${sampleFilePath}`);
-    process.exit(1);
-  }
-
-  const sample = parse<Sample>(sampleFilePath);
-  if (!sample) {
-    console.error(`Failed to parse sample file: ${sampleFilePath}`);
-    process.exit(1);
-  }
-  sample.template = resolveTemplate(samplePath, sample);
-
-  const inputData = parse<Record<string, any>>(dataPath);
-  if (!inputData || !isObject(inputData)) {
-    console.error(`Failed to parse input data file: ${dataPath}`);
-    process.exit(1);
-  }
-
-  const output = compileSample(sample, inputData, {
-    project: options.project || false,
-  });
-
-  if (!isObject(inputData)) {
-    console.error("Input data must be an object.");
-    process.exit(1);
-  }
-
-  createOutputDirectory(outputPath);
-
-  for (const { fileName, content } of output.items) {
-    const itemOutputPath = path.join(outputPath, fileName);
-    fs.writeFileSync(itemOutputPath, content);
-  }
-}
-
-program
-  .command("compile <sample-directory> <data-file> <output-directory>")
-  .option("-p, --project", "Generate project file")
-  .action(compile);
-
-program.parse();
+#!/usr/bin/env node
+
+import { program } from "commander";
+import { compile } from "./compile";
+import { version } from "../package.json";
+
+program
+  .name("@caleuche/cli")
+  .description("Caleuche CLI for compiling samples")
+  .version(version);
+
+program
+  .command("compile <sample-directory> <data-file> <output-directory>")
+  .option("-p, --project", "Generate project file")
+  .action(compile);
+
+program.command("batch <batch-file>").action((batchFile) => {
+  console.log(`Batch compiling samples from ${batchFile}`);
+});
+
+program.parse();

package/src/interfaces.ts

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

package/src/utils.ts

@@ -1,50 +1,71 @@
-import { parse as parseYaml } from "yaml";
-import fs from "fs";
-import path from "path";
-import { Sample } from "@caleuche/core";
-
-export function parse<T>(filePath: string): T | null {
-  try {
-    const fileContent = fs.readFileSync(filePath, "utf-8");
-    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-      return parseYaml(fileContent) as T;
-    }
-    return JSON.parse(fileContent) as T;
-  } catch (error) {
-    return null;
-  }
-}
-
-export function resolveSampleFile(samplePath: string): string {
-  if (isDirectory(samplePath)) {
-    return path.join(samplePath, "sample.yaml");
-  }
-  return samplePath;
-}
-
-export function isDirectory(path: string): boolean {
-  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();
-}
-
-export function createOutputDirectory(outputPath: string) {
-  if (!fs.existsSync(outputPath)) {
-    fs.mkdirSync(outputPath, { recursive: true });
-  }
-}
-
-export function resolveTemplate(samplePath: string, sample: Sample): string {
-  try {
-    const templatePath = path.join(samplePath, sample.template);
-    if (!fs.existsSync(templatePath)) {
-      return sample.template;
-    }
-    return fs.readFileSync(templatePath, "utf-8");
-  } catch (error) {
-    console.error("Error reading template file.");
-    process.exit(1);
-  }
-}
-
-export function isObject(value: any): value is Record<string, any> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
+import { parse as parseYaml } from "yaml";
+import fs from "fs";
+import path from "path";
+import { Sample } from "@caleuche/core";
+
+export function parse<T>(filePath: string): T | null {
+  try {
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+      return parseYaml(fileContent) as T;
+    }
+    return JSON.parse(fileContent) as T;
+  } catch (error) {
+    return null;
+  }
+}
+
+export function resolveSampleFile(samplePath: string): string {
+  if (isDirectory(samplePath)) {
+    return path.join(samplePath, "sample.yaml");
+  }
+  return samplePath;
+}
+
+export function isDirectory(path: string): boolean {
+  return fs.existsSync(path) && fs.lstatSync(path).isDirectory();
+}
+
+export function createOutputDirectory(outputPath: string) {
+  if (!fs.existsSync(outputPath)) {
+    fs.mkdirSync(outputPath, { recursive: true });
+  }
+}
+
+export function resolveTemplate(
+  samplePath: string,
+  sample: Sample,
+): string | null {
+  try {
+    const templatePath = path.join(samplePath, sample.template);
+    if (!fs.existsSync(templatePath)) {
+      return sample.template;
+    }
+    return fs.readFileSync(templatePath, "utf-8");
+  } catch (error) {
+    console.error("Error reading template file.");
+    return null;
+  }
+}
+
+export function isObject(value: any): value is Record<string, any> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function isVariantDefinition(
+  variant: SampleVariant,
+): variant is SampleVariantDefinition {
+  return isObject(variant) && !Array.isArray(variant);
+}
+
+export function isVariantPath(
+  variant: SampleVariant,
+): variant is SampleVariantPath {
+  return typeof variant === "string" && fs.existsSync(variant);
+}
+
+export function isVariantReference(
+  variant: SampleVariant,
+): variant is SampleVariantReference {
+  return typeof variant === "string" && !fs.existsSync(variant);
+}

package/test/bach.test.ts

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

package/test/common.test.ts

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