@ldsg/cli 0.3.31 → 0.3.33

package/src/__tests__/formatter.test.ts

@@ -4,130 +4,133 @@ import {
   formatJson,
   formatPrettyList,
   formatPrettyTree,
-  formatPrettyDiff
-} from '../utils/formatter';
+  formatPrettyDiff,
+} from "../utils/formatter";
 
-describe('formatter', () => {
-  describe('formatSuccess', () => {
-    it('should format success response', () => {
-      const result = formatSuccess({ id: '1' });
-      expect(result).toEqual({ success: true, data: { id: '1' } });
+describe("formatter", () => {
+  describe("formatSuccess", () => {
+    it("should format success response", () => {
+      const result = formatSuccess({ id: "1" });
+      expect(result).toEqual({ success: true, data: { id: "1" } });
     });
   });
 
-  describe('formatError', () => {
-    it('should format error response', () => {
-      const result = formatError('NOT_FOUND', 'Resource not found');
-      expect(result).toEqual({ success: false, error: { code: 'NOT_FOUND', message: 'Resource not found' } });
+  describe("formatError", () => {
+    it("should format error response", () => {
+      const result = formatError("NOT_FOUND", "Resource not found");
+      expect(result).toEqual({
+        success: false,
+        error: { code: "NOT_FOUND", message: "Resource not found" },
+      });
     });
   });
 
-  describe('formatJson', () => {
-    it('should format JSON with 2-space indent', () => {
-      const result = formatJson({ a: 1, b: 'test' });
+  describe("formatJson", () => {
+    it("should format JSON with 2-space indent", () => {
+      const result = formatJson({ a: 1, b: "test" });
       expect(result).toBe('{\n  "a": 1,\n  "b": "test"\n}');
     });
   });
 
-  describe('formatPrettyList', () => {
-    it('should return message for empty list', () => {
-      expect(formatPrettyList([])).toBe('No resources found.');
+  describe("formatPrettyList", () => {
+    it("should return message for empty list", () => {
+      expect(formatPrettyList([])).toBe("No resources found.");
     });
 
-    it('should format list with header and rows', () => {
+    it("should format list with header and rows", () => {
       const resources = [
-        { id: '1', kind: 'application', parentId: null, title: 'App1' },
-        { id: '2', kind: 'form', parentId: '1', title: 'Form1' }
+        { id: "1", kind: "application", parentId: null, title: "App1" },
+        { id: "2", kind: "form", parentId: "1", title: "Form1" },
       ];
       const result = formatPrettyList(resources);
-      expect(result).toContain('ID');
-      expect(result).toContain('KIND');
-      expect(result).toContain('PARENT ID');
-      expect(result).toContain('Total: 2 resource(s)');
+      expect(result).toContain("ID");
+      expect(result).toContain("KIND");
+      expect(result).toContain("PARENT ID");
+      expect(result).toContain("Total: 2 resource(s)");
     });
   });
 
-  describe('formatPrettyTree', () => {
-    it('should format a tree with root and children', () => {
+  describe("formatPrettyTree", () => {
+    it("should format a tree with root and children", () => {
       const tree = {
-        resource: { id: '1', kind: 'application', parentId: null, settings: {} },
+        resource: { id: "1", kind: "application", parentId: null, settings: {} },
         children: [
           {
-            resource: { id: '2', kind: 'form', parentId: '1', settings: {} },
-            children: []
-          }
-        ]
+            resource: { id: "2", kind: "form", parentId: "1", settings: {} },
+            children: [],
+          },
+        ],
       };
 
       const result = formatPrettyTree(tree, false);
-      expect(result).toContain('1');
-      expect(result).toContain('2');
-      expect(result).toContain('└──');
+      expect(result).toContain("1");
+      expect(result).toContain("2");
+      expect(result).toContain("└──");
     });
 
-    it('should show kind prefix with showKind option', () => {
+    it("should show kind prefix with showKind option", () => {
       const tree = {
-        resource: { id: '1', kind: 'application', parentId: null, settings: {} },
-        children: []
+        resource: { id: "1", kind: "application", parentId: null, settings: {} },
+        children: [],
       };
 
       const result = formatPrettyTree(tree, true);
-      expect(result).toContain('[application]');
+      expect(result).toContain("[application]");
     });
   });
 
-  describe('formatPrettyDiff', () => {
-    it('should show no differences message', () => {
+  describe("formatPrettyDiff", () => {
+    it("should show no differences message", () => {
       const diff = {
-        id: '1',
-        kind: 'application',
-        sourceA: 'a.json',
-        sourceB: 'b.json',
+        id: "1",
+        kind: "application",
+        sourceA: "a.json",
+        sourceB: "b.json",
         changed: [],
         added: [],
         removed: [],
-        sideA: { id: '1', kind: 'application', parentId: null, settings: {} },
-        sideB: { id: '1', kind: 'application', parentId: null, settings: {} }
+        sideA: { id: "1", kind: "application", parentId: null, settings: {} },
+        sideB: { id: "1", kind: "application", parentId: null, settings: {} },
       } as any;
 
       const result = formatPrettyDiff(diff);
-      expect(result).toContain('No differences found.');
+      expect(result).toContain("No differences found.");
     });
 
-    it('should show changed fields', () => {
+    it("should show changed fields", () => {
       const diff = {
-        id: '1',
-        kind: 'application',
-        sourceA: 'a.json',
-        sourceB: 'b.json',
-        changed: [{ path: 'settings.title', from: 'Old', to: 'New' }],
+        id: "1",
+        kind: "application",
+        sourceA: "a.json",
+        sourceB: "b.json",
+        changed: [{ path: "settings.title", from: "Old", to: "New" }],
         added: [],
         removed: [],
-        sideA: { id: '1', kind: 'application', parentId: null, settings: {} },
-        sideB: { id: '1', kind: 'application', parentId: null, settings: {} }
+        sideA: { id: "1", kind: "application", parentId: null, settings: {} },
+        sideB: { id: "1", kind: "application", parentId: null, settings: {} },
       } as any;
 
       const result = formatPrettyDiff(diff);
-      expect(result).toContain('settings.title');
-      expect(result).toContain('Old');
-      expect(result).toContain('New');
+      expect(result).toContain("settings.title");
+      expect(result).toContain("Old");
+      expect(result).toContain("New");
     });
 
-    it('should show side-only existence', () => {
+    it("should show side-only existence", () => {
       const diffA: any = {
-        id: '1',
-        kind: 'application',
-        sourceA: 'a.json',
-        sourceB: 'b.json',
+        id: "1",
+        kind: "application",
+        sourceA: "a.json",
+        sourceB: "b.json",
         changed: [],
         added: [],
         removed: [],
         sideA: null,
-        sideB: { id: '1', kind: 'application', parentId: null, settings: {} }
+        sideB: { id: "1", kind: "application", parentId: null, settings: {} },
       };
 
       const result = formatPrettyDiff(diffA);
-      expect(result).toContain('only exists in source B');
+      expect(result).toContain("only exists in source B");
     });
   });
 });

package/src/__tests__/json-file-mutator.test.ts

@@ -1,30 +1,30 @@
-import fs from 'fs-extra';
-import { appendRecord, updateRecord, removeRecord, generateId } from '../utils/json-file-mutator';
-import { SourceData } from '../types/resource-record';
-import { ResourceRecords } from '@ldsg/types';
+import fs from "fs-extra";
+import { appendRecord, updateRecord, removeRecord, generateId } from "../utils/json-file-mutator";
+import { SourceData } from "../types/resource-record";
+import { ResourceRecords } from "@ldsg/types";
 
-jest.mock('fs-extra');
+jest.mock("fs-extra");
 
 const mockedFs = fs as jest.Mocked<typeof fs>;
 
-describe('json-file-mutator', () => {
+describe("json-file-mutator", () => {
   const arrayRecords: ResourceRecords = [
-    { id: '1', kind: 'application', parentId: null, settings: { title: 'App1' } },
-    { id: '2', kind: 'form', parentId: '1', settings: { title: 'Form1' } },
-    { id: '3', kind: 'table', parentId: '1', settings: { title: 'Table1' } },
-    { id: '4', kind: 'field', parentId: '3', settings: { title: 'Field1' } }
+    { id: "1", kind: "application", parentId: null, settings: { title: "App1" } },
+    { id: "2", kind: "form", parentId: "1", settings: { title: "Form1" } },
+    { id: "3", kind: "table", parentId: "1", settings: { title: "Table1" } },
+    { id: "4", kind: "field", parentId: "3", settings: { title: "Field1" } },
   ];
 
   const arraySourceData: SourceData = {
     resourceRecords: arrayRecords,
-    format: 'array',
-    filePath: '/test/data.json'
+    format: "array",
+    filePath: "/test/data.json",
   };
 
   const objectSourceData: SourceData = {
     resourceRecords: arrayRecords,
-    format: 'object',
-    filePath: '/test/data.json'
+    format: "object",
+    filePath: "/test/data.json",
   };
 
   beforeEach(() => {
@@ -32,102 +32,107 @@ describe('json-file-mutator', () => {
     mockedFs.readJson.mockResolvedValue([...arrayRecords]);
   });
 
-  describe('generateId', () => {
-    it('should generate a string id', () => {
+  describe("generateId", () => {
+    it("should generate a string id", () => {
       const id = generateId();
-      expect(typeof id).toBe('string');
+      expect(typeof id).toBe("string");
       expect(id.length).toBeGreaterThan(5);
     });
 
-    it('should generate unique ids', () => {
+    it("should generate unique ids", () => {
       const ids = new Set(Array.from({ length: 10 }, () => generateId()));
       expect(ids.size).toBe(10);
     });
   });
 
-  describe('appendRecord', () => {
-    it('should append a new record to array format', async () => {
+  describe("appendRecord", () => {
+    it("should append a new record to array format", async () => {
       mockedFs.readJson.mockResolvedValue([...arrayRecords]);
 
-      const newRecord = { id: '5', kind: 'form', parentId: '1', settings: { title: 'Form2' } };
+      const newRecord = { id: "5", kind: "form", parentId: "1", settings: { title: "Form2" } };
       const result = await appendRecord(arraySourceData, newRecord);
 
-      expect(result.record.id).toBe('5');
+      expect(result.record.id).toBe("5");
       expect(result.allRecords).toHaveLength(5);
       expect(mockedFs.writeJson).toHaveBeenCalledWith(
-        '/test/data.json',
-        expect.arrayContaining([expect.objectContaining({ id: '5' })]),
-        { spaces: 2 }
+        "/test/data.json",
+        expect.arrayContaining([expect.objectContaining({ id: "5" })]),
+        { spaces: 2 },
       );
     });
 
-    it('should append to object format preserving structure', async () => {
+    it("should append to object format preserving structure", async () => {
       mockedFs.readJson.mockResolvedValue({ resourceRecords: [...arrayRecords] });
 
-      const newRecord = { id: '5', kind: 'form', parentId: '1', settings: {} };
+      const newRecord = { id: "5", kind: "form", parentId: "1", settings: {} };
       await appendRecord(objectSourceData, newRecord);
 
       expect(mockedFs.writeJson).toHaveBeenCalledWith(
-        '/test/data.json',
+        "/test/data.json",
         expect.objectContaining({
-          resourceRecords: expect.arrayContaining([expect.objectContaining({ id: '5' })])
+          resourceRecords: expect.arrayContaining([expect.objectContaining({ id: "5" })]),
         }),
-        { spaces: 2 }
+        { spaces: 2 },
       );
     });
 
-    it('should throw on duplicate id', async () => {
-      const dupRecord = { id: '1', kind: 'application', parentId: null, settings: {} };
-      await expect(appendRecord(arraySourceData, dupRecord)).rejects.toThrow('already exists');
+    it("should throw on duplicate id", async () => {
+      const dupRecord = { id: "1", kind: "application", parentId: null, settings: {} };
+      await expect(appendRecord(arraySourceData, dupRecord)).rejects.toThrow("already exists");
     });
 
-    it('should not write file in dry-run mode', async () => {
-      const newRecord = { id: '5', kind: 'form', parentId: '1', settings: {} };
+    it("should not write file in dry-run mode", async () => {
+      const newRecord = { id: "5", kind: "form", parentId: "1", settings: {} };
       await appendRecord(arraySourceData, newRecord, true);
 
       expect(mockedFs.writeJson).not.toHaveBeenCalled();
     });
   });
 
-  describe('updateRecord', () => {
-    it('should update settings and merge', async () => {
+  describe("updateRecord", () => {
+    it("should update settings and merge", async () => {
       mockedFs.readJson.mockResolvedValue([...arrayRecords]);
 
-      const result = await updateRecord(arraySourceData, '1', { title: 'Updated App', newField: 'value' });
+      const result = await updateRecord(arraySourceData, "1", {
+        title: "Updated App",
+        newField: "value",
+      });
 
-      expect(result.record.settings).toEqual({ title: 'Updated App', newField: 'value' });
+      expect(result.record.settings).toEqual({ title: "Updated App", newField: "value" });
       expect(mockedFs.writeJson).toHaveBeenCalled();
     });
 
-    it('should throw on non-existent id', async () => {
-      await expect(updateRecord(arraySourceData, 'nonexistent', { title: 'x' })).rejects.toThrow('not found');
+    it("should throw on non-existent id", async () => {
+      await expect(updateRecord(arraySourceData, "nonexistent", { title: "x" })).rejects.toThrow(
+        "not found",
+      );
     });
 
-    it('should not write file in dry-run mode', async () => {
-      await updateRecord(arraySourceData, '1', { title: 'Dry Run' }, true);
+    it("should not write file in dry-run mode", async () => {
+      await updateRecord(arraySourceData, "1", { title: "Dry Run" }, true);
 
       expect(mockedFs.writeJson).not.toHaveBeenCalled();
     });
   });
 
-  describe('removeRecord', () => {
-    it('should remove record and its children', async () => {
+  describe("removeRecord", () => {
+    it("should remove record and its children", async () => {
       mockedFs.readJson.mockResolvedValue([...arrayRecords]);
 
-      const result = await removeRecord(arraySourceData, '3');
+      const result = await removeRecord(arraySourceData, "3");
 
       expect(result.removed).toHaveLength(2);
-      expect(result.removed.map((r) => r.id)).toEqual(['3', '4']);
+      expect(result.removed.map((r) => r.id)).toEqual(["3", "4"]);
       expect(result.allRecords).toHaveLength(2);
-      expect(result.allRecords.map((r) => r.id)).toEqual(['1', '2']);
+      expect(result.allRecords.map((r) => r.id)).toEqual(["1", "2"]);
     });
 
-    it('should throw on non-existent id', async () => {
-      await expect(removeRecord(arraySourceData, 'nonexistent')).rejects.toThrow('not found');
+    it("should throw on non-existent id", async () => {
+      await expect(removeRecord(arraySourceData, "nonexistent")).rejects.toThrow("not found");
     });
 
-    it('should not write file in dry-run mode', async () => {
-      const result = await removeRecord(arraySourceData, '3', true);
+    it("should not write file in dry-run mode", async () => {
+      const result = await removeRecord(arraySourceData, "3", true);
 
       expect(result.removed).toHaveLength(2);
       expect(mockedFs.writeJson).not.toHaveBeenCalled();

package/src/__tests__/source-resolver.test.ts

@@ -1,9 +1,9 @@
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-import { resolveSource, isStdinSource, getSourceDescription } from '../utils/source-resolver';
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+import { resolveSource, isStdinSource, getSourceDescription } from "../utils/source-resolver";
 
-jest.mock('fs-extra');
+jest.mock("fs-extra");
 
 const mockedFs = fs as jest.Mocked<typeof fs> & {
   pathExists: jest.Mock;
@@ -11,50 +11,50 @@ const mockedFs = fs as jest.Mocked<typeof fs> & {
   stat: jest.Mock;
 };
 
-describe('source-resolver', () => {
+describe("source-resolver", () => {
   const tmpDir = os.tmpdir();
-  const testFilePath = path.join(tmpDir, 'test-resources.json');
-  const testDirPath = path.join(tmpDir, 'test-resource-dir');
-  const defaultFilePath = path.join(process.cwd(), 'resource-records.json');
+  const testFilePath = path.join(tmpDir, "test-resources.json");
+  const testDirPath = path.join(tmpDir, "test-resource-dir");
+  const defaultFilePath = path.join(process.cwd(), "resource-records.json");
 
   const arrayData = [
-    { id: '1', kind: 'application', parentId: null, settings: {} },
-    { id: '2', kind: 'form', parentId: '1', settings: {} }
+    { id: "1", kind: "application", parentId: null, settings: {} },
+    { id: "2", kind: "form", parentId: "1", settings: {} },
   ];
 
   const objectData = {
-    resourceRecords: [{ id: '1', kind: 'application', parentId: null, settings: {} }]
+    resourceRecords: [{ id: "1", kind: "application", parentId: null, settings: {} }],
   };
 
   beforeEach(() => {
     jest.resetAllMocks();
   });
 
-  describe('resolveSource', () => {
-    it('should read array format JSON file', async () => {
+  describe("resolveSource", () => {
+    it("should read array format JSON file", async () => {
       mockedFs.pathExists.mockResolvedValue(true);
       mockedFs.readJson.mockResolvedValue(arrayData);
       mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
 
       const result = await resolveSource(testFilePath);
       expect(result.resourceRecords).toHaveLength(2);
-      expect(result.format).toBe('array');
+      expect(result.format).toBe("array");
       expect(result.filePath).toBe(testFilePath);
     });
 
-    it('should read object format JSON file', async () => {
+    it("should read object format JSON file", async () => {
       mockedFs.pathExists.mockResolvedValue(true);
       mockedFs.readJson.mockResolvedValue(objectData);
       mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
 
       const result = await resolveSource(testFilePath);
       expect(result.resourceRecords).toHaveLength(1);
-      expect(result.format).toBe('object');
+      expect(result.format).toBe("object");
       expect(result.filePath).toBe(testFilePath);
     });
 
-    it('should read directory by appending default filename', async () => {
-      const dirFile = path.join(testDirPath, 'resource-records.json');
+    it("should read directory by appending default filename", async () => {
+      const dirFile = path.join(testDirPath, "resource-records.json");
       mockedFs.pathExists.mockResolvedValue(true);
       mockedFs.readJson.mockResolvedValue(arrayData);
       mockedFs.stat.mockResolvedValue({ isDirectory: () => true } as fs.Stats);
@@ -64,62 +64,62 @@ describe('source-resolver', () => {
       expect(result.resourceRecords).toHaveLength(2);
     });
 
-    it('should throw on missing default file', async () => {
+    it("should throw on missing default file", async () => {
       mockedFs.pathExists.mockResolvedValue(false);
 
-      await expect(resolveSource(undefined)).rejects.toThrow('Default source file not found');
+      await expect(resolveSource(undefined)).rejects.toThrow("Default source file not found");
     });
 
-    it('should throw on non-existent file', async () => {
+    it("should throw on non-existent file", async () => {
       mockedFs.pathExists.mockResolvedValue(false);
-      mockedFs.stat.mockRejectedValue(new Error('ENOENT'));
-      mockedFs.readJson.mockRejectedValue(new Error('File not found'));
+      mockedFs.stat.mockRejectedValue(new Error("ENOENT"));
+      mockedFs.readJson.mockRejectedValue(new Error("File not found"));
 
-      await expect(resolveSource('/nonexistent/file.json')).rejects.toThrow('Source not found');
+      await expect(resolveSource("/nonexistent/file.json")).rejects.toThrow("Source not found");
     });
 
-    it('should throw on invalid JSON format', async () => {
+    it("should throw on invalid JSON format", async () => {
       mockedFs.pathExists.mockResolvedValue(true);
-      mockedFs.readJson.mockResolvedValue('invalid');
+      mockedFs.readJson.mockResolvedValue("invalid");
       mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
 
-      await expect(resolveSource(testFilePath)).rejects.toThrow('Invalid resource records format');
+      await expect(resolveSource(testFilePath)).rejects.toThrow("Invalid resource records format");
     });
 
-    it('should throw on valid object without resourceRecords field', async () => {
+    it("should throw on valid object without resourceRecords field", async () => {
       mockedFs.pathExists.mockResolvedValue(true);
-      mockedFs.readJson.mockResolvedValue({ foo: 'bar' });
+      mockedFs.readJson.mockResolvedValue({ foo: "bar" });
       mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
 
-      await expect(resolveSource(testFilePath)).rejects.toThrow('Invalid resource records format');
+      await expect(resolveSource(testFilePath)).rejects.toThrow("Invalid resource records format");
     });
   });
 
-  describe('isStdinSource', () => {
-    it('should return true for -', () => {
-      expect(isStdinSource('-')).toBe(true);
+  describe("isStdinSource", () => {
+    it("should return true for -", () => {
+      expect(isStdinSource("-")).toBe(true);
     });
 
-    it('should return false for file paths', () => {
-      expect(isStdinSource('./data.json')).toBe(false);
+    it("should return false for file paths", () => {
+      expect(isStdinSource("./data.json")).toBe(false);
     });
 
-    it('should return false for undefined', () => {
+    it("should return false for undefined", () => {
       expect(isStdinSource(undefined)).toBe(false);
     });
   });
 
-  describe('getSourceDescription', () => {
-    it('should return default path for undefined', () => {
-      expect(getSourceDescription(undefined)).toBe('./resource-records.json');
+  describe("getSourceDescription", () => {
+    it("should return default path for undefined", () => {
+      expect(getSourceDescription(undefined)).toBe("./resource-records.json");
     });
 
     it('should return "stdin" for -', () => {
-      expect(getSourceDescription('-')).toBe('stdin');
+      expect(getSourceDescription("-")).toBe("stdin");
     });
 
-    it('should return the path itself', () => {
-      expect(getSourceDescription('./data.json')).toBe('./data.json');
+    it("should return the path itself", () => {
+      expect(getSourceDescription("./data.json")).toBe("./data.json");
     });
   });
 });