@caleuche/cli 0.1.3 → 0.2.0

package/test/compile.test.ts

@@ -0,0 +1,255 @@
+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,
+  isObject,
+} 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);
+
+import { compile } from "../src/compile";
+
+describe("compile", () => {
+  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();
+  });
+
+  describe("error handling", () => {
+    it("should exit when data file cannot be parsed", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(null);
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse input data file: data.json",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit when data is not an object", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce("not an object");
+      mockIsObject.mockReturnValue(false);
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Failed to parse input data file: data.json",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should exit when compilation fails", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockImplementation(() => {
+        throw new Error("Compilation error");
+      });
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "Error during compilation: Compilation error",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it("should handle unknown compilation errors", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockImplementation(() => {
+        throw "Unknown error";
+      });
+
+      expect(() => {
+        compile("sample", "data.json", "output", {});
+      }).toThrow("process.exit");
+
+      expect(mockConsoleError).toHaveBeenCalledWith(
+        "An unknown error occurred during compilation.",
+      );
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe("successful compilation", () => {
+    it("should compile successfully and write output files", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+      const mockOutput = {
+        items: [
+          { fileName: "sample.js", content: "console.log('test');" },
+          { fileName: "package.json", content: '{"name": "test"}' },
+        ],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockReturnValue(mockOutput);
+      mockCreateOutputDirectory.mockImplementation(() => {});
+      mockFs.writeFileSync.mockImplementation(() => {});
+
+      // This should not throw
+      compile("sample", "data.json", "output", { project: true });
+
+      expect(mockCreateOutputDirectory).toHaveBeenCalledWith("output");
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        path.join("output", "sample.js"),
+        "console.log('test');",
+      );
+      expect(mockFs.writeFileSync).toHaveBeenCalledWith(
+        path.join("output", "package.json"),
+        '{"name": "test"}',
+      );
+    });
+
+    it("should pass correct options to compileSample", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+      const mockOutput = {
+        items: [{ fileName: "sample.js", content: "console.log('test');" }],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockReturnValue(mockOutput);
+      mockCreateOutputDirectory.mockImplementation(() => {});
+      mockFs.writeFileSync.mockImplementation(() => {});
+
+      compile("sample", "data.json", "output", { project: true });
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        { ...mockSample, template: "resolved template" },
+        mockData,
+        { project: true },
+      );
+    });
+
+    it("should default project option to false", () => {
+      const mockSample: Sample = {
+        template: "test template",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+      const mockData = { name: "test" };
+      const mockOutput = {
+        items: [{ fileName: "sample.js", content: "console.log('test');" }],
+      };
+
+      mockResolveSampleFile.mockReturnValue("/path/to/sample.yaml");
+      mockFs.existsSync.mockReturnValue(true);
+      mockParse.mockReturnValueOnce(mockSample);
+      mockResolveTemplate.mockReturnValue("resolved template");
+      mockParse.mockReturnValueOnce(mockData);
+      mockIsObject.mockReturnValue(true);
+      mockCompileSample.mockReturnValue(mockOutput);
+      mockCreateOutputDirectory.mockImplementation(() => {});
+      mockFs.writeFileSync.mockImplementation(() => {});
+
+      compile("sample", "data.json", "output", {});
+
+      expect(mockCompileSample).toHaveBeenCalledWith(
+        { ...mockSample, template: "resolved template" },
+        mockData,
+        { project: false },
+      );
+    });
+  });
+});

package/test/utils.test.ts

@@ -0,0 +1,267 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import { tmpdir } from "os";
+import {
+  parse,
+  resolveSampleFile,
+  isDirectory,
+  createOutputDirectory,
+  resolveTemplate,
+  isObject,
+} from "../src/utils";
+import { Sample } from "@caleuche/core";
+
+function multiline(strings: TemplateStringsArray, ...values: any[]) {
+  let result = strings[0];
+  for (let i = 0; i < values.length; i++) {
+    result += values[i] + strings[i + 1];
+  }
+
+  const lines = result.split("\n");
+
+  if (lines[0].trim() === "") lines.shift();
+  if (lines[lines.length - 1].trim() === "") lines.pop();
+
+  const nonEmptyLines = lines.filter((line) => line.trim() !== "");
+  if (nonEmptyLines.length === 0) return "";
+
+  const minIndent = Math.min(
+    ...nonEmptyLines.map((line) => line.match(/^ */)?.[0].length || 0),
+  );
+
+  return lines.map((line) => line.slice(minIndent)).join("\n");
+}
+
+describe("utils", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(tmpdir(), "caleuche-cli-test-"));
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe("parse", () => {
+    it("should parse valid JSON file", () => {
+      const jsonFile = path.join(tempDir, "test.json");
+      const testData = { name: "test", value: 42 };
+      fs.writeFileSync(jsonFile, JSON.stringify(testData));
+
+      const result = parse(jsonFile);
+      expect(result).toEqual(testData);
+    });
+
+    it("should parse valid YAML file", () => {
+      const yamlFile = path.join(tempDir, "test.yaml");
+      const yamlContent = multiline`
+        name: test
+        value: 42`;
+      fs.writeFileSync(yamlFile, yamlContent);
+
+      const result = parse(yamlFile);
+      expect(result).toEqual({ name: "test", value: 42 });
+    });
+
+    it("should parse valid YML file", () => {
+      const ymlFile = path.join(tempDir, "test.yml");
+      const ymlContent = multiline`
+        name: test
+        value: 42`;
+      fs.writeFileSync(ymlFile, ymlContent);
+
+      const result = parse(ymlFile);
+      expect(result).toEqual({ name: "test", value: 42 });
+    });
+
+    it("should return null for invalid JSON", () => {
+      const invalidJsonFile = path.join(tempDir, "invalid.json");
+      fs.writeFileSync(invalidJsonFile, "{ invalid json }");
+
+      const result = parse(invalidJsonFile);
+      expect(result).toBeNull();
+    });
+
+    it("should return null for invalid YAML", () => {
+      const invalidYamlFile = path.join(tempDir, "invalid.yaml");
+      fs.writeFileSync(
+        invalidYamlFile,
+        multiline`
+        invalid: yaml: structure:
+          broken
+      `,
+      );
+
+      const result = parse(invalidYamlFile);
+      expect(result).toBeNull();
+    });
+
+    it("should return null for non-existent file", () => {
+      const nonExistentFile = path.join(tempDir, "nonexistent.json");
+      const result = parse(nonExistentFile);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("resolveSampleFile", () => {
+    it("should return the file path if it's a file", () => {
+      const filePath = path.join(tempDir, "sample.yaml");
+      fs.writeFileSync(filePath, "test content");
+
+      const result = resolveSampleFile(filePath);
+      expect(result).toBe(filePath);
+    });
+
+    it("should return sample.yaml path if input is a directory", () => {
+      const dirPath = path.join(tempDir, "sample-dir");
+      fs.mkdirSync(dirPath);
+
+      const result = resolveSampleFile(dirPath);
+      expect(result).toBe(path.join(dirPath, "sample.yaml"));
+    });
+
+    it("should return the path as-is if it doesn't exist", () => {
+      const nonExistentPath = path.join(tempDir, "nonexistent");
+
+      const result = resolveSampleFile(nonExistentPath);
+      expect(result).toBe(nonExistentPath);
+    });
+  });
+
+  describe("isDirectory", () => {
+    it("should return true for directories", () => {
+      const dirPath = path.join(tempDir, "testdir");
+      fs.mkdirSync(dirPath);
+
+      expect(isDirectory(dirPath)).toBe(true);
+    });
+
+    it("should return false for files", () => {
+      const filePath = path.join(tempDir, "testfile.txt");
+      fs.writeFileSync(filePath, "test content");
+
+      expect(isDirectory(filePath)).toBe(false);
+    });
+
+    it("should return false for non-existent paths", () => {
+      const nonExistentPath = path.join(tempDir, "nonexistent");
+      expect(isDirectory(nonExistentPath)).toBe(false);
+    });
+  });
+
+  describe("createOutputDirectory", () => {
+    it("should create directory if it doesn't exist", () => {
+      const newDir = path.join(tempDir, "new-output");
+      expect(fs.existsSync(newDir)).toBe(false);
+
+      createOutputDirectory(newDir);
+      expect(fs.existsSync(newDir)).toBe(true);
+      expect(fs.lstatSync(newDir).isDirectory()).toBe(true);
+    });
+
+    it("should create nested directories", () => {
+      const nestedDir = path.join(tempDir, "nested", "output", "dir");
+      expect(fs.existsSync(nestedDir)).toBe(false);
+
+      createOutputDirectory(nestedDir);
+      expect(fs.existsSync(nestedDir)).toBe(true);
+      expect(fs.lstatSync(nestedDir).isDirectory()).toBe(true);
+    });
+
+    it("should not throw if directory already exists", () => {
+      const existingDir = path.join(tempDir, "existing");
+      fs.mkdirSync(existingDir);
+
+      expect(() => createOutputDirectory(existingDir)).not.toThrow();
+    });
+  });
+
+  describe("resolveTemplate", () => {
+    it("should read template file from sample directory", () => {
+      const sampleDir = path.join(tempDir, "sample");
+      fs.mkdirSync(sampleDir);
+
+      const templateContent = "Hello, <%= name %>!";
+      const templateFile = path.join(sampleDir, "template.txt");
+      fs.writeFileSync(templateFile, templateContent);
+
+      const sample: Sample = {
+        template: "template.txt",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      const result = resolveTemplate(sampleDir, sample);
+      expect(result).toBe(templateContent);
+    });
+
+    it("should return template string if file doesn't exist", () => {
+      const sampleDir = path.join(tempDir, "sample");
+      fs.mkdirSync(sampleDir);
+
+      const sample: Sample = {
+        template: "inline template content",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      const result = resolveTemplate(sampleDir, sample);
+      expect(result).toBe("inline template content");
+    });
+
+    it("should handle template files with various extensions", () => {
+      const sampleDir = path.join(tempDir, "sample");
+      fs.mkdirSync(sampleDir);
+
+      const templateContent = "function test() { return 'hello'; }";
+      const templateFile = path.join(sampleDir, "template.js");
+      fs.writeFileSync(templateFile, templateContent);
+
+      const sample: Sample = {
+        template: "template.js",
+        type: "javascript",
+        dependencies: [],
+        input: [],
+      };
+
+      const result = resolveTemplate(sampleDir, sample);
+      expect(result).toBe(templateContent);
+    });
+  });
+
+  describe("isObject", () => {
+    it("should return true for plain objects", () => {
+      expect(isObject({})).toBe(true);
+      expect(isObject({ a: 1, b: 2 })).toBe(true);
+      expect(isObject({ nested: { object: true } })).toBe(true);
+    });
+
+    it("should return false for arrays", () => {
+      expect(isObject([])).toBe(false);
+      expect(isObject([1, 2, 3])).toBe(false);
+      expect(isObject([{}])).toBe(false);
+    });
+
+    it("should return false for null", () => {
+      expect(isObject(null)).toBe(false);
+    });
+
+    it("should return false for primitives", () => {
+      expect(isObject("string")).toBe(false);
+      expect(isObject(42)).toBe(false);
+      expect(isObject(true)).toBe(false);
+      expect(isObject(undefined)).toBe(false);
+    });
+
+    it("should return false for functions", () => {
+      expect(isObject(() => {})).toBe(false);
+      expect(isObject(function () {})).toBe(false);
+    });
+  });
+});

package/tsconfig.json

@@ -1,11 +1,12 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "commonjs",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true
-  },
-  "include": ["src/**/*"]
-}
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"]
+}