@ldsg/cli 0.3.31 → 0.3.32

package/jest.config.js

@@ -1,12 +1,12 @@
 /** @type {import('ts-jest').JestConfigWithTsJest} */
 module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  testMatch: ['**/__tests__/**/*.test.ts'],
+  preset: "ts-jest",
+  testEnvironment: "node",
+  testMatch: ["**/__tests__/**/*.test.ts"],
   moduleNameMapper: {
-    '^@ldsg/types$': '<rootDir>/../types/src',
-    '^@ldsg/constants$': '<rootDir>/../constants/src',
-    '^@ldsg/apaas-to-runtime$': '<rootDir>/../apaas-to-runtime/src',
-    '^@ldsg/utils$': '<rootDir>/../utils/src'
-  }
+    "^@ldsg/types$": "<rootDir>/../types/src",
+    "^@ldsg/constants$": "<rootDir>/../constants/src",
+    "^@ldsg/apaas-to-runtime$": "<rootDir>/../apaas-to-runtime/src",
+    "^@ldsg/utils$": "<rootDir>/../utils/src",
+  },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldsg/cli",
-  "version": "0.3.31",
+  "version": "0.3.32",
   "description": "",
   "keywords": [],
   "license": "ISC",
@@ -13,10 +13,9 @@
     "axios": "^1.7.9",
     "commander": "^12.0.0",
     "fs-extra": "^11.3.0",
-    "jsonata": "^2.0.6",
-    "@ldsg/constants": "0.3.31",
-    "@ldsg/apaas-to-runtime": "0.3.31",
-    "@ldsg/utils": "0.3.31"
+    "@ldsg/apaas-to-runtime": "0.3.32",
+    "@ldsg/constants": "0.3.32",
+    "@ldsg/utils": "0.3.32"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -27,12 +26,14 @@
     "dotenv-cli": "~11.0.0",
     "jest": "^29.5.0",
     "lodash": "^4.17.21",
+    "oxfmt": "latest",
+    "oxlint": "latest",
     "supertest": "^7.1.4",
     "ts-jest": "^29.4.1",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
     "typescript": "^5.3.3",
-    "@ldsg/types": "0.3.31"
+    "@ldsg/types": "0.3.32"
   },
   "publishConfig": {
     "access": "public"
@@ -40,6 +41,8 @@
   "scripts": {
     "build": "tsc --project tsconfig.build.json",
     "cli": "ts-node src/cli.ts",
+    "format": "oxfmt --write src/",
+    "lint": "oxlint src/",
     "test": "jest",
     "test:watch": "jest --watch"
   }

package/src/__tests__/commands.test.ts

@@ -1,257 +1,257 @@
-import { ResourceRecords } from '@ldsg/types';
-import { listResources, getResource, getTree } from '../commands/resource/list';
-import { createResource } from '../commands/resource/create';
-import { updateResource } from '../commands/resource/update';
-import { deleteResource } from '../commands/resource/delete';
-import { diffResource } from '../commands/resource/diff';
-import { SourceData } from '../types/resource-record';
-import fs from 'fs-extra';
+import { ResourceRecords } from "@ldsg/types";
+import { listResources, getResource, getTree } from "../commands/resource/list";
+import { createResource } from "../commands/resource/create";
+import { updateResource } from "../commands/resource/update";
+import { deleteResource } from "../commands/resource/delete";
+import { diffResource } from "../commands/resource/diff";
+import { SourceData } from "../types/resource-record";
+import fs from "fs-extra";
 
-jest.mock('fs-extra');
+jest.mock("fs-extra");
 
 const mockedFs = fs as jest.Mocked<typeof fs>;
 
 const sampleRecords: ResourceRecords = [
-  { id: 'app1', kind: 'application', parentId: null, settings: { title: 'My App' } },
-  { id: 'form1', kind: 'form', parentId: 'app1', settings: { title: 'Login Form' } },
-  { id: 'form2', kind: 'form', parentId: 'app1', settings: { title: 'Register Form' } },
-  { id: 'table1', kind: 'table', parentId: 'app1', settings: { title: 'Users' } },
-  { id: 'field1', kind: 'field', parentId: 'table1', settings: { title: 'Name' } },
-  { id: 'field2', kind: 'field', parentId: 'table1', settings: { title: 'Email' } }
+  { id: "app1", kind: "application", parentId: null, settings: { title: "My App" } },
+  { id: "form1", kind: "form", parentId: "app1", settings: { title: "Login Form" } },
+  { id: "form2", kind: "form", parentId: "app1", settings: { title: "Register Form" } },
+  { id: "table1", kind: "table", parentId: "app1", settings: { title: "Users" } },
+  { id: "field1", kind: "field", parentId: "table1", settings: { title: "Name" } },
+  { id: "field2", kind: "field", parentId: "table1", settings: { title: "Email" } },
 ];
 
 const sourceData: SourceData = {
   resourceRecords: sampleRecords,
-  format: 'array',
-  filePath: '/test/data.json'
+  format: "array",
+  filePath: "/test/data.json",
 };
 
-describe('commands', () => {
+describe("commands", () => {
   beforeEach(() => {
     jest.resetAllMocks();
     mockedFs.readJson.mockResolvedValue([...sampleRecords]);
   });
 
-  describe('listResources', () => {
-    it('should return all records without filter', async () => {
+  describe("listResources", () => {
+    it("should return all records without filter", async () => {
       const result = await listResources(sampleRecords, {});
       expect(result.total).toBe(6);
       expect(result.resources).toHaveLength(6);
     });
 
-    it('should filter by kind', async () => {
-      const result = await listResources(sampleRecords, { kind: 'form' });
+    it("should filter by kind", async () => {
+      const result = await listResources(sampleRecords, { kind: "form" });
       expect(result.total).toBe(2);
-      expect(result.resources.every((r) => r.kind === 'form')).toBe(true);
+      expect(result.resources.every((r) => r.kind === "form")).toBe(true);
     });
 
-    it('should filter by parentId', async () => {
-      const result = await listResources(sampleRecords, { parentId: 'table1' });
+    it("should filter by parentId", async () => {
+      const result = await listResources(sampleRecords, { parentId: "table1" });
       expect(result.total).toBe(2);
-      expect(result.resources.every((r) => r.parentId === 'table1')).toBe(true);
+      expect(result.resources.every((r) => r.parentId === "table1")).toBe(true);
     });
 
-    it('should filter by rootId', async () => {
-      const result = await listResources(sampleRecords, { rootId: 'table1' });
+    it("should filter by rootId", async () => {
+      const result = await listResources(sampleRecords, { rootId: "table1" });
       expect(result.total).toBe(3);
-      expect(result.resources.map((r) => r.id)).toEqual(['table1', 'field1', 'field2']);
+      expect(result.resources.map((r) => r.id)).toEqual(["table1", "field1", "field2"]);
     });
 
-    it('should combine filters', async () => {
-      const result = await listResources(sampleRecords, { kind: 'field', rootId: 'table1' });
+    it("should combine filters", async () => {
+      const result = await listResources(sampleRecords, { kind: "field", rootId: "table1" });
       expect(result.total).toBe(2);
     });
   });
 
-  describe('getResource', () => {
-    it('should get a single resource by id', async () => {
-      const result = await getResource(sampleRecords, 'app1', {});
+  describe("getResource", () => {
+    it("should get a single resource by id", async () => {
+      const result = await getResource(sampleRecords, "app1", {});
       expect(result).not.toBeNull();
-      expect(result!.id).toBe('app1');
+      expect(result!.id).toBe("app1");
     });
 
-    it('should return null for non-existent id', async () => {
-      const result = await getResource(sampleRecords, 'nonexistent', {});
+    it("should return null for non-existent id", async () => {
+      const result = await getResource(sampleRecords, "nonexistent", {});
       expect(result).toBeNull();
     });
 
-    it('should include children when requested', async () => {
-      const result = (await getResource(sampleRecords, 'app1', { children: true })) as any;
+    it("should include children when requested", async () => {
+      const result = (await getResource(sampleRecords, "app1", { children: true })) as any;
       expect(result.children).toHaveLength(3);
-      expect(result.children.map((c: any) => c.id)).toEqual(['form1', 'form2', 'table1']);
+      expect(result.children.map((c: any) => c.id)).toEqual(["form1", "form2", "table1"]);
     });
 
-    it('should return null for non-existent id with tree option', async () => {
-      const result = await getResource(sampleRecords, 'nonexistent', { tree: true });
+    it("should return null for non-existent id with tree option", async () => {
+      const result = await getResource(sampleRecords, "nonexistent", { tree: true });
       expect(result).toBeNull();
     });
   });
 
-  describe('getTree', () => {
-    it('should build tree for specified root', async () => {
-      const result = await getTree(sampleRecords, 'table1');
-      expect(result.rootId).toBe('table1');
-      expect(result.tree.resource.id).toBe('table1');
+  describe("getTree", () => {
+    it("should build tree for specified root", async () => {
+      const result = await getTree(sampleRecords, "table1");
+      expect(result.rootId).toBe("table1");
+      expect(result.tree.resource.id).toBe("table1");
       expect(result.tree.children).toHaveLength(2);
     });
 
-    it('should auto-detect root when only one', async () => {
+    it("should auto-detect root when only one", async () => {
       const singleRoot: ResourceRecords = [
-        { id: 'app1', kind: 'application', parentId: null, settings: {} },
-        { id: 'form1', kind: 'form', parentId: 'app1', settings: {} }
+        { id: "app1", kind: "application", parentId: null, settings: {} },
+        { id: "form1", kind: "form", parentId: "app1", settings: {} },
       ];
       const result = await getTree(singleRoot, undefined);
-      expect(result.rootId).toBe('app1');
+      expect(result.rootId).toBe("app1");
     });
 
-    it('should throw for non-existent root', async () => {
-      await expect(getTree(sampleRecords, 'nonexistent')).rejects.toThrow('not found');
+    it("should throw for non-existent root", async () => {
+      await expect(getTree(sampleRecords, "nonexistent")).rejects.toThrow("not found");
     });
   });
 
-  describe('createResource', () => {
-    it('should create with explicit fields', async () => {
+  describe("createResource", () => {
+    it("should create with explicit fields", async () => {
       mockedFs.readJson.mockResolvedValue([...sampleRecords]);
 
       const result = await createResource({
         sourceData,
-        kind: 'form',
-        parentId: 'app1',
-        settings: { title: 'New Form' }
+        kind: "form",
+        parentId: "app1",
+        settings: { title: "New Form" },
       });
 
-      expect(result.record.kind).toBe('form');
-      expect(result.record.parentId).toBe('app1');
-      expect(result.record.settings).toEqual({ title: 'New Form' });
+      expect(result.record.kind).toBe("form");
+      expect(result.record.parentId).toBe("app1");
+      expect(result.record.settings).toEqual({ title: "New Form" });
       expect(mockedFs.writeJson).toHaveBeenCalled();
     });
 
-    it('should throw without kind', async () => {
+    it("should throw without kind", async () => {
       await expect(
         createResource({
           sourceData,
-          parentId: 'app1'
-        } as any)
-      ).rejects.toThrow('--kind');
+          parentId: "app1",
+        } as any),
+      ).rejects.toThrow("--kind");
     });
 
-    it('should throw without parent-id', async () => {
+    it("should throw without parent-id", async () => {
       await expect(
         createResource({
           sourceData,
-          kind: 'form'
-        } as any)
-      ).rejects.toThrow('--parent-id');
+          kind: "form",
+        } as any),
+      ).rejects.toThrow("--parent-id");
     });
   });
 
-  describe('updateResource', () => {
-    it('should update existing resource', async () => {
+  describe("updateResource", () => {
+    it("should update existing resource", async () => {
       mockedFs.readJson.mockResolvedValue([...sampleRecords]);
 
       const result = await updateResource({
         sourceData,
-        id: 'form1',
-        settings: { title: 'Updated Form' }
+        id: "form1",
+        settings: { title: "Updated Form" },
       });
 
-      expect(result.record.id).toBe('form1');
-      expect(result.record.settings).toEqual({ title: 'Updated Form' });
+      expect(result.record.id).toBe("form1");
+      expect(result.record.settings).toEqual({ title: "Updated Form" });
       expect(mockedFs.writeJson).toHaveBeenCalled();
     });
 
-    it('should throw on non-existent id', async () => {
+    it("should throw on non-existent id", async () => {
       await expect(
         updateResource({
           sourceData,
-          id: 'nonexistent',
-          settings: { title: 'x' }
-        })
-      ).rejects.toThrow('not found');
+          id: "nonexistent",
+          settings: { title: "x" },
+        }),
+      ).rejects.toThrow("not found");
     });
   });
 
-  describe('deleteResource', () => {
-    it('should delete resource and children', async () => {
+  describe("deleteResource", () => {
+    it("should delete resource and children", async () => {
       mockedFs.readJson.mockResolvedValue([...sampleRecords]);
 
       const result = await deleteResource({
         sourceData,
-        id: 'table1'
+        id: "table1",
       });
 
       expect(result.removed).toHaveLength(3);
-      expect(result.removed.map((r) => r.id)).toEqual(['table1', 'field1', 'field2']);
+      expect(result.removed.map((r) => r.id)).toEqual(["table1", "field1", "field2"]);
     });
 
-    it('should throw on non-existent id', async () => {
+    it("should throw on non-existent id", async () => {
       await expect(
         deleteResource({
           sourceData,
-          id: 'nonexistent'
-        })
-      ).rejects.toThrow('not found');
+          id: "nonexistent",
+        }),
+      ).rejects.toThrow("not found");
     });
   });
 
-  describe('diffResource', () => {
+  describe("diffResource", () => {
     const recordsA: ResourceRecords = [
-      { id: '1', kind: 'application', parentId: null, settings: { title: 'App A', version: 1 } }
+      { id: "1", kind: "application", parentId: null, settings: { title: "App A", version: 1 } },
     ];
     const recordsB: ResourceRecords = [
       {
-        id: '1',
-        kind: 'application',
+        id: "1",
+        kind: "application",
         parentId: null,
-        settings: { title: 'App B', version: 1, newField: 'new' }
-      }
+        settings: { title: "App B", version: 1, newField: "new" },
+      },
     ];
 
-    it('should detect changed fields', async () => {
+    it("should detect changed fields", async () => {
       const result = await diffResource({
-        sourceA: 'a.json',
-        sourceB: 'b.json',
-        id: '1',
+        sourceA: "a.json",
+        sourceB: "b.json",
+        id: "1",
         recordsA,
-        recordsB
+        recordsB,
       });
 
       expect(result.changed.length).toBeGreaterThan(0);
-      expect(result.changed.some((c) => c.path === 'title')).toBe(true);
+      expect(result.changed.some((c) => c.path === "title")).toBe(true);
     });
 
-    it('should detect added fields', async () => {
+    it("should detect added fields", async () => {
       const result = await diffResource({
-        sourceA: 'a.json',
-        sourceB: 'b.json',
-        id: '1',
+        sourceA: "a.json",
+        sourceB: "b.json",
+        id: "1",
         recordsA,
-        recordsB
+        recordsB,
       });
 
-      expect(result.added.some((a) => a.path === 'newField')).toBe(true);
+      expect(result.added.some((a) => a.path === "newField")).toBe(true);
     });
 
-    it('should handle resource only in one side', async () => {
+    it("should handle resource only in one side", async () => {
       const result = await diffResource({
-        sourceA: 'a.json',
-        sourceB: 'b.json',
-        id: '2',
+        sourceA: "a.json",
+        sourceB: "b.json",
+        id: "2",
         recordsA: [],
-        recordsB: [{ id: '2', kind: 'application', parentId: null, settings: {} }]
+        recordsB: [{ id: "2", kind: "application", parentId: null, settings: {} }],
       });
 
       expect(result.sideA).toBeNull();
       expect(result.sideB).not.toBeNull();
     });
 
-    it('should report no differences for identical resources', async () => {
+    it("should report no differences for identical resources", async () => {
       const result = await diffResource({
-        sourceA: 'a.json',
-        sourceB: 'b.json',
-        id: '1',
+        sourceA: "a.json",
+        sourceB: "b.json",
+        id: "1",
         recordsA,
-        recordsB: recordsA
+        recordsB: recordsA,
       });
 
       expect(result.changed).toHaveLength(0);