@ldsg/cli 0.3.38 → 0.3.41

package/src/__tests__/mutate.test.ts

@@ -0,0 +1,392 @@
+import axios from "axios";
+import fs from "fs-extra";
+import { ResourceRecords } from "@ldsg/types";
+import {
+  applyIdMapToRecords,
+  buildIdMap,
+  buildMutatePlan,
+  mutateRecordsDirect,
+  mutateResourceRecords,
+  mutateResources,
+  pullRemoteResourceRecords,
+  purifyResourceRecord,
+} from "../commands/resource/mutate";
+import { SourceData } from "../types/resource-record";
+import { DEFAULT_RRM_GRAPHQL_ENDPOINT } from "../constants";
+
+jest.mock("axios");
+jest.mock("fs-extra");
+
+const mockedAxios = axios as jest.Mocked<typeof axios>;
+const mockedFs = fs as jest.Mocked<typeof fs>;
+
+const localRecords: ResourceRecords = [
+  {
+    id: "app-temp-1",
+    kind: "application",
+    parentId: null,
+    settings: { slug: "my-app", title: "My App", description: "" },
+  },
+  {
+    id: "form-temp-1",
+    kind: "form",
+    parentId: "app-temp-1",
+    settings: { slug: "login", title: "Login", description: "" },
+  },
+  {
+    id: "existing-app",
+    kind: "application",
+    parentId: null,
+    settings: { slug: "existing-application", title: "Existing App", description: "", extra: true },
+  },
+];
+
+const remoteRecords: ResourceRecords = [
+  {
+    id: "existing-app",
+    kind: "application",
+    parentId: null,
+    settings: { slug: "existing-application", title: "Existing App", description: "" },
+  },
+  {
+    id: "remote-only-app",
+    kind: "application",
+    parentId: null,
+    settings: { slug: "remote-only-application", title: "Remote Only", description: "" },
+  },
+];
+
+const sourceData: SourceData = {
+  resourceRecords: localRecords,
+  format: "array",
+  filePath: "/tmp/resource-records.json",
+};
+
+describe("mutate command", () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe("purifyResourceRecord", () => {
+    it("should keep only id, kind, parentId, settings", () => {
+      const result = purifyResourceRecord({
+        id: "x",
+        kind: "table",
+        parentId: "app1",
+        settings: { title: "T" },
+        extraField: "nope",
+      } as any);
+
+      expect(result).toEqual({
+        id: "x",
+        kind: "table",
+        parentId: "app1",
+        settings: { title: "T" },
+      });
+      expect(result).not.toHaveProperty("extraField");
+    });
+  });
+
+  describe("buildMutatePlan", () => {
+    it("should split create/update/delete like console", () => {
+      const plan = buildMutatePlan(localRecords, remoteRecords);
+
+      expect(plan.createResourceRecords.map((r) => r.id)).toEqual(["app-temp-1", "form-temp-1"]);
+      expect(plan.updateResourceRecords.map((r) => r.id)).toEqual(["existing-app"]);
+      expect(plan.deleteResourceRecords.map((r) => r.id)).toEqual(["remote-only-app"]);
+      expect(plan.deleteResourceRecords[0].settings.isDeleted).toBe(true);
+      expect(plan.remoteCount).toBe(2);
+      expect(plan.localCount).toBe(3);
+    });
+
+    it("should skip soft-delete when deleteMissing=false", () => {
+      const plan = buildMutatePlan(localRecords, remoteRecords, { deleteMissing: false });
+      expect(plan.deleteResourceRecords).toHaveLength(0);
+      expect(plan.createResourceRecords).toHaveLength(2);
+    });
+  });
+
+  describe("replaceIdsDeep / applyIdMapToRecords", () => {
+    it("should replace id, parentId and settings references", () => {
+      const idMap = {
+        "app-temp-1": "6a76d34f09e2c7630c859301",
+        "form-temp-1": "6a76d34f09e2c7630c859302",
+      };
+
+      const result = applyIdMapToRecords(localRecords, idMap);
+
+      expect(result[0].id).toBe("6a76d34f09e2c7630c859301");
+      expect(result[1].parentId).toBe("6a76d34f09e2c7630c859301");
+      expect(result[1].id).toBe("6a76d34f09e2c7630c859302");
+    });
+
+    it("should replace exact-string values inside settings", () => {
+      const record: any = {
+        id: "obj-temp",
+        kind: "object",
+        parentId: "app-temp-1",
+        settings: {
+          databaseResourceId: "app-temp-1",
+          title: "keep app-temp-1 as literal substring?",
+        },
+      };
+      const result = applyIdMapToRecords([record], { "app-temp-1": "SERVER-APP" }) as any;
+
+      expect(result[0].settings.databaseResourceId).toBe("SERVER-APP");
+      expect(result[0].settings.title).toBe("keep app-temp-1 as literal substring?");
+    });
+  });
+
+  describe("buildIdMap", () => {
+    it("should map by index and skip identity", () => {
+      const map = buildIdMap(
+        [
+          { id: "a", kind: "k", parentId: null, settings: {} },
+          { id: "b", kind: "k", parentId: null, settings: {} },
+        ],
+        [
+          { id: "server-a", kind: "k", parentId: null, settings: {} },
+          { id: "b", kind: "k", parentId: null, settings: {} },
+        ],
+      );
+
+      expect(map).toEqual({ a: "server-a" });
+    });
+
+    it("should return empty map on length mismatch", () => {
+      const map = buildIdMap([{ id: "a", kind: "k", parentId: null, settings: {} }], []);
+      expect(map).toEqual({});
+    });
+  });
+
+  describe("mutateResourceRecords", () => {
+    it("should POST the exact mutation payload", async () => {
+      mockedAxios.post.mockResolvedValue({
+        data: {
+          data: {
+            mutateResourceRecords: {
+              createdResourceRecords: [{ id: "s1" }],
+              updatedResourceRecords: [{ id: "u1" }],
+            },
+          },
+        },
+      });
+
+      const res = await mutateResourceRecords({
+        endpoint: DEFAULT_RRM_GRAPHQL_ENDPOINT,
+        token: "TOKEN",
+        createResourceRecords: [{ id: "a", kind: "k", parentId: null, settings: {} }],
+        updateResourceRecords: [],
+      });
+
+      const [, body, config] = mockedAxios.post.mock.calls[0];
+      expect((body as any).variables.createResourceRecords).toEqual([
+        { id: "a", kind: "k", parentId: null, settings: {} },
+      ]);
+      expect((config as any).headers.authorization).toBe("Bearer TOKEN");
+      expect((body as any).query).toContain("mutateResourceRecords");
+      expect(res.createdResourceRecords[0].id).toBe("s1");
+    });
+
+    it("should throw on GraphQL errors", async () => {
+      mockedAxios.post.mockResolvedValue({
+        data: { errors: [{ message: "boom" }] },
+      });
+
+      await expect(
+        mutateResourceRecords({
+          endpoint: DEFAULT_RRM_GRAPHQL_ENDPOINT,
+          createResourceRecords: [],
+          updateResourceRecords: [],
+        }),
+      ).rejects.toThrow("boom");
+    });
+  });
+
+  describe("mutateResources (auto mode)", () => {
+    beforeEach(() => {
+      mockedAxios.post.mockImplementation(async (url, body: any) => {
+        const query = String(body.query ?? "");
+        if (query.includes("resourceRecordConnection")) {
+          return {
+            data: {
+              data: {
+                resourceRecordConnection: {
+                  pageInfo: { hasNextPage: false },
+                  edges: remoteRecords.map((r) => ({ node: r })),
+                },
+              },
+            },
+          };
+        }
+        if (query.includes("mutateResourceRecords")) {
+          return {
+            data: {
+              data: {
+                mutateResourceRecords: {
+                  createdResourceRecords: [
+                    { id: "SERVER-APP", kind: "application", parentId: null, settings: {} },
+                    { id: "SERVER-FORM", kind: "form", parentId: "SERVER-APP", settings: {} },
+                  ],
+                  updatedResourceRecords: [],
+                },
+              },
+            },
+          };
+        }
+        return { data: {} };
+      });
+    });
+
+    it("should return plan only in dry-run mode without calling mutation", async () => {
+      const res = await mutateResources({ sourceData, dryRun: true });
+
+      expect(res.dryRun).toBe(true);
+      expect(res.plan.createResourceRecords).toHaveLength(2);
+      expect(mockedAxios.post).toHaveBeenCalledTimes(1); // 只拉取了远端
+    });
+
+    it("should throw when token missing and there are writes", async () => {
+      await expect(mutateResources({ sourceData })).rejects.toThrow(/token/i);
+    });
+
+    it("should throw requiring --yes when soft-deleting", async () => {
+      process.env.RRM_ACCESS_TOKEN = "ENV_TOKEN";
+      await expect(mutateResources({ sourceData })).rejects.toThrow(/--yes/);
+      delete process.env.RRM_ACCESS_TOKEN;
+    });
+
+    it("should mutate, write back ids and confirm deletion with --yes", async () => {
+      mockedFs.writeJson.mockResolvedValue(undefined as never);
+
+      const res = await mutateResources({ sourceData, token: "TOKEN", yes: true });
+
+      expect(res.idMap).toEqual({ "app-temp-1": "SERVER-APP", "form-temp-1": "SERVER-FORM" });
+      expect(res.writeBackPath).toBe("/tmp/resource-records.json");
+      expect(mockedFs.writeJson).toHaveBeenCalledWith(
+        "/tmp/resource-records.json",
+        [
+          {
+            id: "SERVER-APP",
+            kind: "application",
+            parentId: null,
+            settings: { slug: "my-app", title: "My App", description: "" },
+          },
+          {
+            id: "SERVER-FORM",
+            kind: "form",
+            parentId: "SERVER-APP",
+            settings: { slug: "login", title: "Login", description: "" },
+          },
+          {
+            id: "existing-app",
+            kind: "application",
+            parentId: null,
+            settings: {
+              slug: "existing-application",
+              title: "Existing App",
+              description: "",
+              extra: true,
+            },
+          },
+        ],
+        { spaces: 2 },
+      );
+    });
+
+    it("should skip write-back when --no-write-back", async () => {
+      const res = await mutateResources({
+        sourceData,
+        token: "TOKEN",
+        yes: true,
+        writeBack: false,
+      });
+      expect(res.writeBackPath).toBeUndefined();
+      expect(mockedFs.writeJson).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("mutateRecordsDirect (explicit mode)", () => {
+    it("should POST exactly the given records without fetching remote", async () => {
+      mockedAxios.post.mockResolvedValue({
+        data: {
+          data: {
+            mutateResourceRecords: {
+              createdResourceRecords: [{ id: "server-1" }],
+              updatedResourceRecords: [],
+            },
+          },
+        },
+      });
+
+      const res = await mutateRecordsDirect({
+        endpoint: DEFAULT_RRM_GRAPHQL_ENDPOINT,
+        token: "TOKEN",
+        createResourceRecords: [{ id: "temp-1", kind: "table", parentId: null, settings: {} }],
+        updateResourceRecords: [{ id: "u1", kind: "table", parentId: null, settings: {} }],
+      });
+
+      expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+      const [, body] = mockedAxios.post.mock.calls[0];
+      expect((body as any).variables.createResourceRecords).toEqual([
+        { id: "temp-1", kind: "table", parentId: null, settings: {} },
+      ]);
+      expect((body as any).variables.updateResourceRecords).toEqual([
+        { id: "u1", kind: "table", parentId: null, settings: {} },
+      ]);
+      expect(res.createCount).toBe(1);
+      expect(res.updateCount).toBe(1);
+    });
+
+    it("should not POST in dry-run mode", async () => {
+      const res = await mutateRecordsDirect({
+        endpoint: DEFAULT_RRM_GRAPHQL_ENDPOINT,
+        token: "TOKEN",
+        createResourceRecords: [{ id: "a", kind: "k", parentId: null, settings: {} }],
+        updateResourceRecords: [],
+        dryRun: true,
+      });
+
+      expect(res.dryRun).toBe(true);
+      expect(mockedAxios.post).not.toHaveBeenCalled();
+    });
+
+    it("should throw when token missing", async () => {
+      await expect(
+        mutateRecordsDirect({
+          endpoint: DEFAULT_RRM_GRAPHQL_ENDPOINT,
+          createResourceRecords: [{ id: "a", kind: "k", parentId: null, settings: {} }],
+          updateResourceRecords: [],
+        }),
+      ).rejects.toThrow(/token/i);
+    });
+  });
+
+  describe("pullRemoteResourceRecords", () => {
+    it("should fetch remote records and write to output file", async () => {
+      mockedAxios.post.mockResolvedValue({
+        data: {
+          data: {
+            resourceRecordConnection: {
+              pageInfo: { hasNextPage: false },
+              edges: remoteRecords.map((r) => ({ node: r })),
+            },
+          },
+        },
+      });
+      mockedFs.writeJson.mockResolvedValue(undefined as never);
+
+      const res = await pullRemoteResourceRecords({
+        endpoint: DEFAULT_RRM_GRAPHQL_ENDPOINT,
+        output: "/tmp/pulled.json",
+      });
+
+      expect(res.count).toBe(2);
+      expect(res.outputPath).toBe("/tmp/pulled.json");
+      expect(mockedFs.writeJson).toHaveBeenCalledWith("/tmp/pulled.json", remoteRecords, {
+        spaces: 2,
+      });
+      expect(mockedAxios.post).toHaveBeenCalledTimes(1);
+    });
+  });
+});

package/src/cli.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env node
 import { readFileSync } from "fs";
 import { join } from "path";
-import { convertApaasResourceRecordsToResourceRecords } from "@ldsg/apaas-to-runtime";
 import { AppData } from "@ldsg/types";
 import {
   extendAppData,
@@ -28,8 +27,13 @@ import { updateResource } from "./commands/resource/update";
 import { deleteResource } from "./commands/resource/delete";
 import { listResources, getTree } from "./commands/resource/list";
 import { getResource } from "./commands/resource/get";
-import { convertResource } from "./commands/resource/convert";
 import { diffResource } from "./commands/resource/diff";
+import {
+  mutateRecordsDirect,
+  mutateResources,
+  pullRemoteResourceRecords,
+  purifyResourceRecord,
+} from "./commands/resource/mutate";
 
 const { version } = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 
@@ -42,12 +46,16 @@ program
   .aliases(["g", "gen"])
   .description("Generate standalone application from resource records")
   .option("--app-data-uri <uri>", "runtime app data URI")
-  .option("--apaas-app-data-uri <uri>", "aPaaS app data URI (GraphQL)")
   .option(
-    "--apaas-app-data-expression <expression>",
-    "JSONata expression for aPaaS data extraction",
+    "--app-data-expression <expression>",
+    "runtime app data expression (jsonata), used to convert source data to standard ldsg resource records",
   )
   .option("--using-workspace-ldsg-module", "use workspace ldsg module mode")
+  .option(
+    "--layout <layout>",
+    `app layout: nested or flat (default: flat for workspace mode, nested otherwise)`,
+  )
+  .option("--app-package-name <name>", "app package name (default: @ldsg/app)")
   .option(
     "-o, --output <path>",
     `output directory for prepared app code (default: ${DEFAULT_OUTPUT_PATH})`,
@@ -57,27 +65,32 @@ program
 
     const usingWorkspaceLdsgModule = options.usingWorkspaceLdsgModule ?? false;
 
-    const { resourceRecords, sourceType } = await loadAppResourceRecords({
+    const layout =
+      options.layout === "nested"
+        ? ZipAppDataLayout.NESTED
+        : options.layout === "flat"
+          ? ZipAppDataLayout.FLAT
+          : undefined;
+    if (options.layout && layout === undefined) {
+      throw new Error(`invalid layout: ${options.layout} (expected nested or flat)`);
+    }
+
+    const { resourceRecords } = await loadAppResourceRecords({
       appDataUri: options.appDataUri,
-      apaasAppDataUri: options.apaasAppDataUri,
-      apaasAppDataExpression: options.apaasAppDataExpression,
+      appDataExpression: options.appDataExpression,
     });
 
-    let appData: AppData;
-
-    if (sourceType === "apaas") {
-      const { targetResourceRecords } = convertApaasResourceRecordsToResourceRecords({
-        resourceRecords,
-      });
-      appData = { resourceRecords: targetResourceRecords };
-    } else {
-      appData = { resourceRecords };
-    }
+    const appData: AppData = { resourceRecords };
 
     let extendAppDataParams: ExtendAppDataParams;
 
     if (usingWorkspaceLdsgModule) {
-      extendAppDataParams = await getExtendAppDataParamsUsingWorkspaceLdsgModule({ appData });
+      extendAppDataParams = await getExtendAppDataParamsUsingWorkspaceLdsgModule({
+        appData,
+        ...(layout ? { layout } : {}),
+        ...(options.appPackageName ? { appPackageName: options.appPackageName } : {}),
+        outputPath,
+      });
     } else {
       extendAppDataParams = await getExtendAppDataParamsUsingNpmLdsgModule({ appData });
     }
@@ -87,7 +100,7 @@ program
     await prepare({
       ...extendAppDataRes,
       outputPath,
-      ...(usingWorkspaceLdsgModule ? { layout: ZipAppDataLayout.FLAT } : {}),
+      ...(layout ? { layout } : usingWorkspaceLdsgModule ? { layout: ZipAppDataLayout.FLAT } : {}),
     });
   });
 
@@ -324,40 +337,6 @@ resource
     }
   });
 
-resource
-  .command("convert")
-  .description("Convert resource records between aPaaS and Runtime formats")
-  .option("--from <format>", "source format (apaas or runtime)")
-  .option("--to <format>", "target format (apaas or runtime)")
-  .option("--input <path>", "input file path")
-  .option("--output <path>", "output file path (omit for stdout)")
-  .action(async (options) => {
-    try {
-      if (!options.from || !options.to || !options.input) {
-        console.error(
-          formatJson(formatError("MISSING_ARGS", "Required options: --from, --to, --input")),
-        );
-        process.exit(1);
-      }
-
-      const result = await convertResource({
-        from: options.from,
-        to: options.to,
-        input: options.input,
-        output: options.output,
-      });
-
-      if (result.outputPath) {
-        console.log(formatJson(formatSuccess({ outputPath: result.outputPath })));
-      } else {
-        console.log(formatJson(formatSuccess({ data: result.data })));
-      }
-    } catch (error) {
-      console.error(formatJson(formatError("CONVERT_ERROR", (error as Error).message)));
-      process.exit(1);
-    }
-  });
-
 resource
   .command("diff <id>")
   .description("Diff a resource between two sources")
@@ -395,4 +374,150 @@ resource
     }
   });
 
+resource
+  .command("pull")
+  .description("Pull resource records from RRM to a local file (read-only)")
+  .option("--endpoint <url>", "RRM GraphQL endpoint")
+  .option("--path <regex>", "scope remote records to a path regex (e.g. application id)")
+  .option("-o, --output <path>", `output file (default: ${DEFAULT_SOURCE_PATH})`)
+  .action(async (options) => {
+    try {
+      const result = await pullRemoteResourceRecords({
+        endpoint: options.endpoint,
+        path: options.path,
+        output: options.output,
+      });
+
+      console.log(formatJson(formatSuccess(result)));
+    } catch (error) {
+      console.error(formatJson(formatError("PULL_ERROR", (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
+async function parseExplicitRecords(
+  value?: string,
+  file?: string,
+): Promise<
+  | { id: string; kind: string; parentId: string | null; settings: Record<string, unknown> }[]
+  | undefined
+> {
+  if (value && file) {
+    throw new Error("Cannot use both an inline value and a file for the same record list");
+  }
+
+  let data: unknown;
+
+  if (file) {
+    const fs = await import("fs-extra");
+    data = await fs.readJson(file);
+  } else if (value) {
+    data = JSON.parse(value);
+  } else {
+    return undefined;
+  }
+
+  const list = Array.isArray(data) ? data : [data];
+  return list.map((record) => purifyResourceRecord(record as never));
+}
+
+resource
+  .command("mutate")
+  .description("Mutate local resource records on RRM via mutateResourceRecords")
+  .option("--source <path>", `data source (default: ${DEFAULT_SOURCE_PATH})`)
+  .option("--endpoint <url>", "RRM GraphQL endpoint")
+  .option("--token <token>", "RRM Bearer token (or RRM_ACCESS_TOKEN env)")
+  .option(
+    "--path <regex>",
+    "scope remote records to a path regex (e.g. application id) before splitting",
+  )
+  .option(
+    "--no-delete-missing",
+    "do not soft-delete remote-only records (default: soft-delete like console)",
+  )
+  .option("--no-write-back", "do not write server-assigned ids back to the local source file")
+  .option("--yes", "confirm soft-deletion without prompting")
+  .option("--dry-run", "preview the plan without sending")
+  .option("--create <json>", "explicit create records as JSON (skip auto split)")
+  .option("--update <json>", "explicit update records as JSON (skip auto split)")
+  .option("--create-file <path>", "explicit create records from JSON file (skip auto split)")
+  .option("--update-file <path>", "explicit update records from JSON file (skip auto split)")
+  .action(async (options) => {
+    try {
+      const explicitCreate = await parseExplicitRecords(options.create, options.createFile);
+      const explicitUpdate = await parseExplicitRecords(options.update, options.updateFile);
+
+      if (explicitCreate !== undefined || explicitUpdate !== undefined) {
+        const result = await mutateRecordsDirect({
+          endpoint: options.endpoint,
+          token: options.token,
+          createResourceRecords: explicitCreate ?? [],
+          updateResourceRecords: explicitUpdate ?? [],
+          dryRun: options.dryRun,
+        });
+
+        console.log(
+          formatJson(
+            formatSuccess({
+              mode: "explicit",
+              dryRun: result.dryRun,
+              createCount: result.createCount,
+              updateCount: result.updateCount,
+              createdResourceRecords: result.createdResourceRecords,
+              updatedResourceRecords: result.updatedResourceRecords,
+            }),
+          ),
+        );
+        return;
+      }
+
+      if (isStdinSource(options.source)) {
+        console.error(
+          formatJson(
+            formatError(
+              "STDIN_NOT_SUPPORTED",
+              "stdin source is not supported for mutate; use a local JSON file",
+            ),
+          ),
+        );
+        process.exit(1);
+      }
+
+      const sourceData = await resolveSource(options.source);
+
+      const result = await mutateResources({
+        sourceData,
+        endpoint: options.endpoint,
+        token: options.token,
+        path: options.path,
+        deleteMissing: options.deleteMissing,
+        writeBack: options.writeBack,
+        yes: options.yes,
+        dryRun: options.dryRun,
+      });
+
+      const { plan } = result;
+
+      console.log(
+        formatJson(
+          formatSuccess({
+            mode: "auto",
+            dryRun: result.dryRun,
+            source: getSourceDescription(options.source),
+            remoteCount: plan.remoteCount,
+            localCount: plan.localCount,
+            createCount: plan.createResourceRecords.length,
+            updateCount: plan.updateResourceRecords.length,
+            deleteCount: plan.deleteResourceRecords.length,
+            idMap: result.idMap,
+            writeBackPath: result.writeBackPath,
+          }),
+        ),
+      );
+    } catch (error) {
+      console.error(formatJson(formatError("MUTATE_ERROR", (error as Error).message)));
+      process.exit(1);
+    }
+  });
+
 program.parse(process.argv);

package/src/commands/resource/create.ts

@@ -1,4 +1,4 @@
-import { ResourceRecord } from "@ldsg/types";
+import { ResourceRecord, ResourceSettings } from "@ldsg/types";
 import { SourceData } from "../../types/resource-record";
 import { appendRecord, generateId } from "../../utils/json-file-mutator";
 
@@ -26,7 +26,7 @@ export async function createResource(options: CreateOptions): Promise<{ record:
       id: partial.id || generateId(),
       kind: partial.kind,
       parentId: partial.parentId ?? sourceData.resourceRecords[0]?.parentId ?? null,
-      settings: (partial.settings || {}) as Record<string, unknown>,
+      settings: (partial.settings || {}) as ResourceSettings,
     };
   } else {
     if (!options.kind) {
@@ -40,7 +40,7 @@ export async function createResource(options: CreateOptions): Promise<{ record:
       id: options.id || generateId(),
       kind: options.kind,
       parentId: options.parentId ?? null,
-      settings: options.settings || {},
+      settings: (options.settings || {}) as ResourceSettings,
     };
   }