@ldsg/cli 0.3.42 → 0.3.44

package/src/__tests__/mutate.test.ts

@@ -1,392 +0,0 @@
-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/__tests__/source-resolver.test.ts

@@ -1,125 +0,0 @@
-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");
-
-const mockedFs = fs as jest.Mocked<typeof fs> & {
-  pathExists: jest.Mock;
-  readJson: jest.Mock;
-  stat: jest.Mock;
-};
-
-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 arrayData = [
-    { id: "1", kind: "application", parentId: null, settings: {} },
-    { id: "2", kind: "form", parentId: "1", settings: {} },
-  ];
-
-  const objectData = {
-    resourceRecords: [{ id: "1", kind: "application", parentId: null, settings: {} }],
-  };
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-  });
-
-  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.filePath).toBe(testFilePath);
-    });
-
-    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.filePath).toBe(testFilePath);
-    });
-
-    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);
-
-      const result = await resolveSource(testDirPath);
-      expect(mockedFs.readJson).toHaveBeenCalledWith(dirFile);
-      expect(result.resourceRecords).toHaveLength(2);
-    });
-
-    it("should throw on missing default file", async () => {
-      mockedFs.pathExists.mockResolvedValue(false);
-
-      await expect(resolveSource(undefined)).rejects.toThrow("Default source file not found");
-    });
-
-    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"));
-
-      await expect(resolveSource("/nonexistent/file.json")).rejects.toThrow("Source not found");
-    });
-
-    it("should throw on invalid JSON format", async () => {
-      mockedFs.pathExists.mockResolvedValue(true);
-      mockedFs.readJson.mockResolvedValue("invalid");
-      mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
-
-      await expect(resolveSource(testFilePath)).rejects.toThrow("Invalid resource records format");
-    });
-
-    it("should throw on valid object without resourceRecords field", async () => {
-      mockedFs.pathExists.mockResolvedValue(true);
-      mockedFs.readJson.mockResolvedValue({ foo: "bar" });
-      mockedFs.stat.mockResolvedValue({ isDirectory: () => false } as fs.Stats);
-
-      await expect(resolveSource(testFilePath)).rejects.toThrow("Invalid resource records format");
-    });
-  });
-
-  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 undefined", () => {
-      expect(isStdinSource(undefined)).toBe(false);
-    });
-  });
-
-  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");
-    });
-
-    it("should return the path itself", () => {
-      expect(getSourceDescription("./data.json")).toBe("./data.json");
-    });
-  });
-});

package/src/types/get-extend-app-data-params.ts

@@ -1,13 +0,0 @@
-import { AppData } from "@ldsg/types";
-import { ExtendAppDataParams, ZipAppDataLayout } from "@ldsg/utils";
-
-interface GetExtendAppDataParamsParams {
-  appData: AppData;
-  layout?: ZipAppDataLayout;
-  appPackageName?: string;
-  outputPath?: string;
-}
-
-export type GetExtendAppDataParams = (
-  params: GetExtendAppDataParamsParams,
-) => Promise<ExtendAppDataParams>;

package/src/utils/get-extend-app-data-params-using-npm-ldsg-module.ts

@@ -1,34 +0,0 @@
-import { FILES_IN_APP_TEMPLATE_MODULE } from "@ldsg/constants";
-import { ExtendAppDataParams } from "@ldsg/utils";
-import _ from "lodash";
-import { GetExtendAppDataParams } from "../types/get-extend-app-data-params";
-import { addPnpmOverrides } from "./add-pnpm-overrides";
-
-export const getExtendAppDataParamsUsingNpmLdsgModule: GetExtendAppDataParams = async (params) => {
-  const { appData } = params;
-
-  const packageJsonFile = FILES_IN_APP_TEMPLATE_MODULE.find((file) => file.path === "package.json");
-
-  /**
-   * 替换模块版本
-   */
-  _.set(packageJsonFile, 'data.dependencies["@ldsg/create-app"]', "latest");
-  _.set(packageJsonFile, 'data.dependencies["@ldsg/opentelemetry-node"]', "latest");
-
-  /**
-   * 通过 pnpm-workspace.yaml 的 overrides 统一 graphql 相关依赖版本
-   * 版本号从 package.json 的 dependencies 中读取
-   */
-  const graphqlDeps = ["graphql", "graphql-middleware", "graphql-shield"];
-  const pnpmWorkspaceFile = addPnpmOverrides(FILES_IN_APP_TEMPLATE_MODULE, graphqlDeps);
-
-  let res: ExtendAppDataParams = {
-    appData,
-    extraAppData: {
-      reuseMainAppDependencies: graphqlDeps,
-      filesInAppModele: [...FILES_IN_APP_TEMPLATE_MODULE, packageJsonFile, pnpmWorkspaceFile],
-    },
-  };
-
-  return res;
-};