@pronto-tools-and-more/network-process 3.3.9

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@pronto-tools-and-more/network-process",
+  "version": "3.3.9",
+  "description": "",
+  "main": "src/networkProcessMain.js",
+  "type": "module",
+  "scripts": {
+    "test": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --detectOpenHandles --forceExit",
+    "test:watch": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --watch",
+    "type-check": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@lvce-editor/assert": "^1.2.0",
+    "@lvce-editor/ipc": "^9.1.0",
+    "@lvce-editor/json-rpc": "^1.3.0",
+    "@lvce-editor/verror": "^1.3.0",
+    "archiver": "^7.0.1",
+    "extract-zip": "^2.0.1",
+    "ky": "^1.2.4"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.2",
+    "@types/node": "^20.12.7",
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "injectGlobals": false
+  }
+}

package/src/networkProcessMain.js

@@ -0,0 +1,3 @@
+import * as Main from "./parts/Main/Main.js";
+
+Main.main();

package/src/parts/Assert/Assert.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/assert";

package/src/parts/Callback/Callback.js

@@ -0,0 +1 @@
+export { resolve } from "@lvce-editor/json-rpc";

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandState from "../CommandState/CommandState.js";
+
+export const execute = (command, ...args) => {
+  const fn = CommandState.getCommand(command);
+  if (!fn) {
+    throw new Error(`Command not found ${command}`);
+  }
+  return fn(...args);
+};

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,16 @@
+import * as CreateZip from "../CreateZip/CreateZip.js";
+import * as DownloadZipFile from "../DownloadZipFile/DownloadZipFile.js";
+import * as ExtractZip from "../ExtractZip/ExtractZip.js";
+import * as GetListContentZipFilesResponse from "../GetListContentZipFilesResponse/GetListContentZipFilesResponse.js";
+import * as Login from "../Login/Login.js";
+import * as UploadZip from "../UploadZip/UploadZip.js";
+
+export const commandMap = {
+  "Network.uploadZip": UploadZip.uploadZip,
+  "Network.createZip": CreateZip.createZip,
+  "Network.downloadZipFile": DownloadZipFile.downloadZipFile,
+  "Network.extractZip": ExtractZip.extractZip,
+  "Network.getListContentZipFilesResponse":
+    GetListContentZipFilesResponse.getListContentZipFilesResponse,
+  "Network.login": Login.login,
+};

package/src/parts/CommandState/CommandState.js

@@ -0,0 +1,17 @@
+export const state = {
+  commands: Object.create(null),
+};
+
+export const registerCommand = (key, fn) => {
+  state.commands[key] = fn;
+};
+
+export const registerCommands = (commandMap) => {
+  for (const [key, value] of Object.entries(commandMap)) {
+    registerCommand(key, value);
+  }
+};
+
+export const getCommand = (key) => {
+  return state.commands[key];
+};

package/src/parts/CreateZip/CreateZip.js

@@ -0,0 +1,25 @@
+import { VError } from "@lvce-editor/verror";
+import archiver from "archiver";
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+import { dirname } from "path";
+import * as Assert from "../Assert/Assert.js";
+
+export const createZip = async ({ inDir, outFile }) => {
+  try {
+    Assert.string(inDir);
+    Assert.string(outFile);
+    const archive = archiver("zip", {
+      zlib: { level: 9 }, // Sets the compression level.
+    });
+    await mkdir(dirname(outFile), { recursive: true });
+    const outStream = createWriteStream(outFile);
+    const promise = pipeline(archive, outStream);
+    archive.directory(inDir, false);
+    await archive.finalize();
+    await promise;
+  } catch (error) {
+    throw new VError(error, `Failed to create zip`);
+  }
+};

package/src/parts/DownloadZipFile/DownloadZipFile.js

@@ -0,0 +1,36 @@
+import { VError } from "@lvce-editor/verror";
+import ky from "ky";
+import { createWriteStream } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { pipeline } from "node:stream/promises";
+import * as Assert from "../Assert/Assert.js";
+
+export const downloadZipFile = async ({
+  zipFileId,
+  downloadBaseUrl,
+  sessionId,
+  outFile,
+}) => {
+  try {
+    Assert.string(zipFileId);
+    Assert.string(downloadBaseUrl);
+    Assert.string(sessionId);
+    Assert.string(outFile);
+    const response = await ky(downloadBaseUrl, {
+      searchParams: {
+        appResourcesId: zipFileId,
+        sessionID: sessionId,
+      },
+    });
+    if (!response.body) {
+      throw new Error("missing body");
+    }
+    await mkdir(dirname(outFile), { recursive: true });
+    const outStream = createWriteStream(outFile);
+    await pipeline(response.body, outStream);
+    return response;
+  } catch (error) {
+    throw new VError(error, `Failed to download zip file`);
+  }
+};

package/src/parts/ExtractZip/ExtractZip.js

@@ -0,0 +1,13 @@
+import { VError } from "@lvce-editor/verror";
+import * as Assert from "../Assert/Assert.js";
+import extract from "extract-zip";
+
+export const extractZip = async ({ inFile, outDir }) => {
+  try {
+    Assert.string(inFile);
+    Assert.string(outDir);
+    await extract(inFile, { dir: outDir });
+  } catch (error) {
+    throw new VError(error, `Failed to extract zip`);
+  }
+};

package/src/parts/GetFormData/GetFormData.js

@@ -0,0 +1,9 @@
+import * as Assert from "../Assert/Assert.js";
+
+export const getFormData = async (blob, fileName) => {
+  Assert.object(blob);
+  Assert.string(fileName);
+  const body = new FormData();
+  body.set("file", blob, fileName);
+  return body;
+};

package/src/parts/GetListContentZipFilesResponse/GetListContentZipFilesResponse.js

@@ -0,0 +1,78 @@
+import { VError } from "@lvce-editor/verror";
+import ky from "ky";
+import * as Assert from "../Assert/Assert.js";
+import * as GetXr from "../GetXr/GetXr.js";
+
+const getBodyJson = () => {
+  return {
+    pageNumber: 0,
+    pageSize: 1,
+    sortBy: "created",
+    sortDirection: "asc",
+    filters: [],
+    t: "cri",
+  };
+};
+
+const getHeaders = () => {
+  const xr = GetXr.getXr();
+  return {
+    accept: "*/*",
+    "accept-language": "en,en-US;q=0.9",
+    "content-type": "application/json",
+    priority: "u=1, i",
+    "sec-ch-ua":
+      '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
+    "sec-ch-ua-mobile": "?0",
+    "sec-ch-ua-platform": '"Linux"',
+    "sec-fetch-dest": "empty",
+    "sec-fetch-mode": "cors",
+    "sec-fetch-site": "same-origin",
+    xr,
+    // TODO
+    cookie: "",
+    Referer: "https://purplemanager.com/",
+    "Referrer-Policy": "strict-origin-when-cross-origin",
+  };
+};
+
+export const getListContentZipFilesResponse = async ({
+  listResourcesUrl,
+  sessionId,
+  appId,
+}) => {
+  try {
+    Assert.string(listResourcesUrl);
+    const body = getBodyJson();
+    const headers = getHeaders();
+    const response = await ky(listResourcesUrl, {
+      json: body,
+      method: "post",
+      headers,
+      searchParams: {
+        appId,
+        sessionID: sessionId,
+        xr: headers.xr,
+      },
+    });
+    const result = await response.json();
+    return result;
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.name === "HTTPError") {
+      // @ts-ignore
+      const serverMessage = await error.response.text();
+      if (serverMessage === "INTERNAL_ERROR") {
+        throw new Error(
+          "Failed to list content zip files: internal error. Hint: Check invalid credentials too many requests"
+        );
+      }
+      if (serverMessage) {
+        throw new Error(
+          `Failed to list content zip files: Server ${serverMessage}`
+        );
+      }
+    }
+    throw new VError(error, `Failed to list content zip files`);
+  }
+};

package/src/parts/GetXr/GetXr.js

@@ -0,0 +1,4 @@
+export const getXr = () => {
+  const xr = Math.random().toFixed(8).toString();
+  return xr;
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,10 @@
+import * as HandleMessage from "../HandleMessage/HandleMessage.js";
+
+export const handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", HandleMessage.handleMessage);
+  } else if ("on" in ipc) {
+    // deprecated
+    ipc.on("message", HandleMessage.handleMessage);
+  }
+};

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,27 @@
+import * as Callback from "../Callback/Callback.js";
+import * as Command from "../Command/Command.js";
+import * as JsonRpc from "../JsonRpc/JsonRpc.js";
+
+const prepare = (error) => {
+  return error;
+};
+
+const requiresSocket = (method) => {
+  return false;
+};
+
+const logError = (error, prettyError) => {
+  console.error(error);
+};
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(
+    event.target,
+    event.data,
+    Command.execute,
+    Callback.resolve,
+    prepare,
+    logError,
+    requiresSocket,
+  );
+};

package/src/parts/IpcChild/IpcChild.js

@@ -0,0 +1,15 @@
+import * as IpcChildModule from "../IpcChildModule/IpcChildModule.js";
+
+export const listen = async ({ method, ...params }) => {
+  const module = await IpcChildModule.getModule(method);
+  // @ts-ignore
+  const rawIpc = await module.listen(params);
+  // @ts-ignore
+  if (module.signal) {
+    // @ts-ignore
+    module.signal(rawIpc);
+  }
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};

package/src/parts/IpcChildModule/IpcChildModule.js

@@ -0,0 +1,25 @@
+import {
+  IpcChildWithElectronMessagePort,
+  IpcChildWithElectronUtilityProcess,
+  IpcChildWithNodeForkedProcess,
+  IpcChildWithNodeWorker,
+  IpcChildWithWebSocket,
+} from "@lvce-editor/ipc";
+import * as IpcChildType from "../IpcChildType/IpcChildType.js";
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcChildType.NodeForkedProcess:
+      return IpcChildWithNodeForkedProcess;
+    case IpcChildType.NodeWorker:
+      return IpcChildWithNodeWorker;
+    case IpcChildType.ElectronUtilityProcess:
+      return IpcChildWithElectronUtilityProcess;
+    case IpcChildType.ElectronMessagePort:
+      return IpcChildWithElectronMessagePort;
+    case IpcChildType.WebSocket:
+      return IpcChildWithWebSocket;
+    default:
+      throw new Error("unexpected ipc type");
+  }
+};

package/src/parts/IpcChildType/IpcChildType.js

@@ -0,0 +1,20 @@
+export const NodeWorker = 1;
+export const NodeForkedProcess = 2;
+export const ElectronUtilityProcess = 3;
+export const ElectronMessagePort = 4;
+export const NodeMessagePort = 5;
+export const WebSocket = 6;
+
+export const Auto = () => {
+  const { argv } = process;
+  if (argv.includes("--ipc-type=node-worker")) {
+    return NodeWorker;
+  }
+  if (argv.includes("--ipc-type=node-forked-process")) {
+    return NodeForkedProcess;
+  }
+  if (argv.includes("--ipc-type=electron-utility-process")) {
+    return ElectronUtilityProcess;
+  }
+  throw new Error(`[shared-process] unknown ipc type`);
+};

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/json-rpc";

package/src/parts/Listen/Listen.js

@@ -0,0 +1,8 @@
+import * as HandleIpc from "../HandleIpc/HandleIpc.js";
+import * as IpcChild from "../IpcChild/IpcChild.js";
+import * as IpcChildType from "../IpcChildType/IpcChildType.js";
+
+export const listen = async () => {
+  const ipc = await IpcChild.listen({ method: IpcChildType.Auto() });
+  HandleIpc.handleIpc(ipc);
+};

package/src/parts/Login/Login.js

@@ -0,0 +1,52 @@
+import { VError } from "@lvce-editor/verror";
+import ky from "ky";
+import * as Assert from "../Assert/Assert.js";
+import * as GetXr from "../GetXr/GetXr.js";
+
+const getBodyJson = (userEmail, userPassword) => {
+  Assert.string(userEmail);
+  Assert.string(userPassword);
+  return {
+    email: userEmail,
+    password: userPassword,
+    permanent: true,
+  };
+};
+
+const getHeaders = () => {
+  const xr = GetXr.getXr();
+  return {
+    accept: "*/*",
+    "content-type": "application/json",
+    xr,
+  };
+};
+
+/**
+ *
+ * @param {*} param0
+ * @returns {Promise<any>}
+ */
+export const login = async ({ loginUrl, userEmail, userPassword }) => {
+  try {
+    Assert.string(loginUrl);
+    const body = getBodyJson(userEmail, userPassword);
+    const headers = getHeaders();
+    const response = await ky(loginUrl, {
+      json: body,
+      method: "post",
+      headers,
+    });
+    return response.json();
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.name === "HTTPError") {
+      // @ts-ignore
+      const serverMessage = await error.response.text();
+      if (serverMessage === "INTERNAL_ERROR") {
+        throw new Error("Failed to login: Internal error. Hint: Check headers");
+      }
+    }
+    throw new VError(error, `Failed to login`);
+  }
+};

package/src/parts/Main/Main.js

@@ -0,0 +1,8 @@
+import * as CommandMap from "../CommandMap/CommandMap.js";
+import * as CommandState from "../CommandState/CommandState.js";
+import * as Listen from "../Listen/Listen.js";
+
+export const main = async () => {
+  CommandState.registerCommands(CommandMap.commandMap);
+  await Listen.listen();
+};

package/src/parts/UploadZip/UploadZip.js

@@ -0,0 +1,66 @@
+import { VError } from "@lvce-editor/verror";
+import { openAsBlob } from "fs";
+import ky from "ky";
+import * as Assert from "../Assert/Assert.js";
+import * as GetFormData from "../GetFormData/GetFormData.js";
+import * as GetXr from "../GetXr/GetXr.js";
+
+const getHeaders = () => {
+  const xr = GetXr.getXr();
+  return {
+    xr,
+  };
+};
+
+export const uploadZip = async ({
+  file,
+  uploadBaseUrl,
+  preview,
+  appId,
+  sessionId,
+  uploadTimeout,
+  message,
+}) => {
+  try {
+    Assert.string(file);
+    Assert.string(uploadBaseUrl);
+    Assert.boolean(preview);
+    Assert.number(uploadTimeout);
+    Assert.string(message);
+    Assert.string(sessionId);
+    Assert.string(appId);
+
+    const blob = await openAsBlob(file, {
+      type: "application/zip",
+    });
+    const formData = await GetFormData.getFormData(blob, `${message}.zip`);
+    const headers = getHeaders();
+    const response = await ky.post(uploadBaseUrl, {
+      headers,
+      body: formData,
+      searchParams: {
+        preview,
+        appId,
+        sessionID: sessionId,
+        xr: headers.xr,
+      },
+      timeout: uploadTimeout,
+    });
+    return response.text();
+  } catch (error) {
+    // @ts-ignore
+    if (error && error.name === "HTTPError") {
+      // @ts-ignore
+      const serverMessage = await error.response.text();
+      if (serverMessage === "INTERNAL_ERROR") {
+        throw new Error(
+          "Failed to list upload zip file: internal error. Hint: Check headers"
+        );
+      }
+      if (serverMessage) {
+        throw new Error(`Failed to upload zip file: Server ${serverMessage}`);
+      }
+    }
+    throw new VError(error, `Failed to upload zip`);
+  }
+};