Home Reference Source

cables_dev/cables_electron/src/electron/electron_endpoint.js

  1. // eslint-disable-next-line import/no-extraneous-dependencies
  2. import { net, protocol, session, shell } from "electron";
  3. import fs from "fs";
  4. import path from "path";
  5. import mime from "mime";
  7. import cables from "../cables.js";
  8. import logger from "../utils/logger.js";
  9. import doc from "../utils/doc_util.js";
  10. import opsUtil from "../utils/ops_util.js";
  11. import subPatchOpUtil from "../utils/subpatchop_util.js";
  12. import settings from "./electron_settings.js";
  13. import helper from "../utils/helper_util.js";
  14. import electronApp from "./main.js";
  15. import projectsUtil from "../utils/projects_util.js";
  17. protocol.registerSchemesAsPrivileged([
  18.     {
  19.         "scheme": "cables",
  20.         "privileges": {
  21.             "bypassCSP": true,
  22.             "supportFetchAPI": true
  23.         }
  24.     },
  25.     {
  26.         "scheme": "file",
  27.         "privileges": {
  28.             "stream": true,
  29.             "bypassCSP": true,
  30.             "supportFetchAPI": true
  31.         }
  32.     }
  33. ]);
  35. class ElectronEndpoint
  36. {
  37.     constructor()
  38.     {
  39.         this._log = logger;
  40.     }
  42.     init()
  43.     {
  44.         const partition = settings.SESSION_PARTITION;
  45.         const ses = session.fromPartition(partition, { "cache": false });
  47.         ses.protocol.handle("file", async (request) =>
  48.         {
  49.             let urlFile = request.url;
  50.             let absoluteFile = helper.fileURLToPath(urlFile, false);
  51.             let projectFile = helper.fileURLToPath(urlFile, true);
  52.             if (fs.existsSync(absoluteFile))
  53.             {
  54.                 Object.defineProperty(request, "url", { "value": helper.pathToFileURL(absoluteFile) });
  55.                 const response = await net.fetch(request, { "bypassCustomProtocolHandlers": true });
  56.                 this._addDefaultHeaders(request, response, absoluteFile);
  57.                 return response;
  58.             }
  59.             else if (fs.existsSync(projectFile))
  60.             {
  61.                 Object.defineProperty(request, "url", { "value": helper.pathToFileURL(projectFile) });
  62.                 const response = await net.fetch(request, { "bypassCustomProtocolHandlers": true });
  63.                 this._addDefaultHeaders(request, response, projectFile);
  64.                 return response;
  65.             }
  66.             else
  67.             {
  68.                 try
  69.                 {
  70.                     if (projectFile.includes("?"))
  71.                     {
  72.                         projectFile = projectFile.split("?")[0];
  73.                     }
  74.                     if (fs.existsSync(projectFile))
  75.                     {
  76.                         const response = await net.fetch(helper.pathToFileURL(projectFile), { "bypassCustomProtocolHandlers": true });
  77.                         this._addDefaultHeaders(request, response, projectFile);
  78.                         return response;
  79.                     }
  80.                     else
  81.                     {
  82.                         return new Response(null, { "headers": { "status": 404 } });
  83.                     }
  84.                 }
  85.                 catch (e)
  86.                 {
  87.                     return net.fetch(request.url, { "bypassCustomProtocolHandlers": true });
  88.                 }
  89.             }
  90.         });
  92.         ses.protocol.handle("cables", async (request) =>
  93.         {
  94.             const url = new URL(request.url);
  95.             const urlPath = url.pathname;
  96.             const queryParams = new URLSearchParams(url.search);
  97.             const params = {};
  98.             const req = request;
  99.             req.params = params;
  100.             req.query = {};
  101.             for (let key in queryParams)
  102.             {
  103.                 req.query[key] = queryParams.get(key);
  104.             }
  105.             if (urlPath.startsWith("/api/corelib/"))
  106.             {
  107.                 req.params.name = urlPath.split("/", 4)[3];
  108.                 const libCode = this.apiGetCoreLibs(req);
  109.                 if (libCode)
  110.                 {
  111.                     return new Response(libCode, {
  112.                         "headers": { "content-type": "application/javascript" }
  113.                     });
  114.                 }
  115.                 else
  116.                 {
  117.                     return new Response(libCode, {
  118.                         "headers": { "content-type": "application/javascript" },
  119.                         "status": 500
  120.                     });
  121.                 }
  122.             }
  123.             else if (urlPath.startsWith("/api/lib/"))
  124.             {
  125.                 req.params.name = urlPath.split("/", 4)[3];
  126.                 const libCode = this.apiGetLibs(req);
  127.                 if (libCode)
  128.                 {
  129.                     return new Response(libCode, {
  130.                         "headers": { "content-type": "application/javascript" }
  131.                     });
  132.                 }
  133.                 else
  134.                 {
  135.                     return new Response(libCode, {
  136.                         "headers": { "content-type": "application/javascript" },
  137.                         "status": 500
  138.                     });
  139.                 }
  140.             }
  141.             else if (urlPath.startsWith("/api/oplib/"))
  142.             {
  143.                 const parts = urlPath.split("/", 5);
  144.                 let opName = parts[3];
  145.                 let libName = parts[4];
  146.                 if (opsUtil.isOpId(opName))
  147.                 {
  148.                     opName = opsUtil.getOpNameById(opName);
  149.                 }
  150.                 if (opName)
  151.                 {
  152.                     const opPath = opsUtil.getOpAbsolutePath(opName);
  153.                     const libPath = path.join(opPath, libName);
  154.                     const libUrl = helper.pathToFileURL(libPath);
  155.                     const response = await net.fetch(libUrl, { "bypassCustomProtocolHandlers": true });
  156.                     this._addDefaultHeaders(request, response, libPath);
  157.                     return response;
  158.                 }
  159.                 else
  160.                 {
  161.                     return new Response("", {
  162.                         "headers": { "content-type": "application/javascript" },
  163.                         "status": 404
  164.                     });
  165.                 }
  166.             }
  167.             else if (urlPath === "/api/changelog")
  168.             {
  169.                 return new Response(JSON.stringify(this.apiGetChangelog(req)), {
  170.                     "headers": { "content-type": "application/json" }
  171.                 });
  172.             }
  173.             else if (urlPath.startsWith("/api/ops/code/project"))
  174.             {
  175.                 const code = this.apiGetProjectOpsCode(req);
  176.                 return new Response(code, {
  177.                     "headers": { "content-type": "application/json" }
  178.                 });
  179.             }
  180.             else if (urlPath.startsWith("/api/ops/code"))
  181.             {
  182.                 const code = this.apiGetCoreOpsCode(req);
  183.                 if (code)
  184.                 {
  185.                     return new Response(code, {
  186.                         "headers": { "content-type": "application/javascript" }
  187.                     });
  188.                 }
  189.                 else
  190.                 {
  191.                     return new Response(code, {
  192.                         "headers": { "content-type": "application/javascript" },
  193.                         "status": 500
  194.                     });
  195.                 }
  196.             }
  197.             else if (urlPath.startsWith("/api/op/layout/"))
  198.             {
  199.                 let opName = urlPath.split("/", 5)[4];
  200.                 if (opsUtil.isOpId(opName))
  201.                 {
  202.                     opName = opsUtil.getOpNameById(opName);
  203.                 }
  204.                 req.params.opName = opName;
  205.                 const layoutSvg = this.apiOpLayout(req);
  206.                 if (layoutSvg)
  207.                 {
  208.                     return new Response(layoutSvg, {
  209.                         "headers": { "content-type": "image/svg+xml" }
  210.                     });
  211.                 }
  212.                 else
  213.                 {
  214.                     return new Response("", {
  215.                         "headers": { "content-type": "image/svg+xml" },
  216.                         "status": 500
  217.                     });
  218.                 }
  219.             }
  220.             else if (urlPath.startsWith("/api/op/"))
  221.             {
  222.                 let opName = urlPath.split("/", 4)[3];
  223.                 if (opsUtil.isOpId(opName))
  224.                 {
  225.                     opName = opsUtil.getOpNameById(opName);
  226.                 }
  227.                 if (opName)
  228.                 {
  229.                     req.params.opName = opName;
  230.                     const opCode = this.apiGetOpCode(req);
  231.                     if (opCode)
  232.                     {
  233.                         return new Response(opCode, {
  234.                             "headers": { "content-type": "application/javascript" }
  235.                         });
  236.                     }
  237.                     else
  238.                     {
  239.                         return new Response(opCode, {
  240.                             "headers": { "content-type": "application/javascript" },
  241.                             "status": 500
  242.                         });
  243.                     }
  244.                 }
  245.                 else
  246.                 {
  247.                     return new Response("", {
  248.                         "headers": { "content-type": "application/javascript" },
  249.                         "status": 404
  250.                     });
  251.                 }
  252.             }
  253.             else if (urlPath.startsWith("/op/screenshot"))
  254.             {
  255.                 let opName = urlPath.split("/", 4)[3];
  256.                 if (opName) opName = opName.replace(/.png$/, "");
  257.                 const absoluteFile = opsUtil.getOpAbsolutePath(opName);
  258.                 const file = path.join(absoluteFile, "screenshot.png");
  259.                 const response = await net.fetch(helper.pathToFileURL(file), { "bypassCustomProtocolHandlers": true });
  260.                 this._addDefaultHeaders(request, response, file);
  261.                 return response;
  262.             }
  263.             else if (urlPath.startsWith("/edit/"))
  264.             {
  265.                 let patchId = urlPath.split("/", 3)[2];
  266.                 let projectFile = null;
  267.                 if (patchId)
  268.                 {
  269.                     projectFile = settings.getRecentProjectFile(patchId);
  270.                 }
  271.                 if (projectFile)
  272.                 {
  273.                     await electronApp.openPatch(projectFile, true);
  274.                 }
  275.                 else
  276.                 {
  277.                     await electronApp.pickProjectFileDialog();
  278.                 }
  279.                 return new Response(null, { "status": 302 });
  280.             }
  281.             else if (urlPath.startsWith("/openDir/"))
  282.             {
  283.                 let dir = urlPath.replace("/openDir/", "");
  284.                 await shell.showItemInFolder(dir);
  285.                 return new Response(null, { "status": 404 });
  286.             }
  287.             else
  288.             {
  289.                 return new Response("", {
  290.                     "headers": { "content-type": "application/javascript" },
  291.                     "status": 404
  292.                 });
  293.             }
  294.         });
  295.     }
  297.     apiGetCoreOpsCode(req)
  298.     {
  299.         const preview = req.query.preview;
  300.         const opDocs = doc.getOpDocs();
  301.         const code = opsUtil.buildCode(cables.getCoreOpsPath(), null, true, true, opDocs, preview);
  302.         if (!code) this._log.warn("FAILED TO GET CODE FOR COREOPS FROM", cables.getCoreOpsPath());
  303.         return code;
  304.     }
  306.     apiGetProjectOpsCode(req)
  307.     {
  308.         const preview = req.query.preview;
  309.         const project = settings.getCurrentProject();
  311.         let code = "";
  312.         let missingOps = [];
  313.         if (project)
  314.         {
  315.             let opDocs = doc.getOpDocs(true, true);
  316.             let allOps = [];
  317.             if (project.ops) allOps = project.ops.filter((op) => { return !opDocs.some((d) => { return d.id === op.opId; }); });
  318.             const opsInProjectDir = projectsUtil.getOpDocsInProjectDirs(project);
  319.             const opsInSubPatches = subPatchOpUtil.getOpsUsedInSubPatches(project);
  320.             allOps = allOps.concat(opsInProjectDir);
  321.             allOps = allOps.concat(opsInSubPatches);
  322.             missingOps = allOps.filter((op) => { return !opDocs.some((d) => { return d.id === op.opId || d.id === op.id; }); });
  323.         }
  325.         const opsWithCode = [];
  326.         let codeNamespaces = [];
  328.         missingOps.forEach((missingOp) =>
  329.         {
  330.             const opId = missingOp.opId || missingOp.id;
  331.             const opName = missingOp.name || opsUtil.getOpNameById(opId);
  332.             if (opId && opName)
  333.             {
  334.                 if (!opsWithCode.includes(opName))
  335.                 {
  336.                     const parts = opName.split(".");
  337.                     for (let k = 1; k < parts.length; k++)
  338.                     {
  339.                         let partPartname = "";
  340.                         for (let j = 0; j < k; j++) partPartname += parts[j] + ".";
  342.                         partPartname = partPartname.substr(0, partPartname.length - 1);
  343.                         codeNamespaces.push(partPartname + "=" + partPartname + " || {};");
  344.                     }
  345.                     const fn = opsUtil.getOpAbsoluteFileName(opName);
  346.                     if (fn)
  347.                     {
  348.                         code += opsUtil.getOpFullCode(fn, opName, opId);
  349.                         opsWithCode.push(opName);
  350.                     }
  351.                 }
  352.                 doc.addOpToLookup(opId, opName);
  353.             }
  354.         });
  356.         codeNamespaces = helper.sortAndReduce(codeNamespaces);
  357.         let fullCode = opsUtil.OPS_CODE_PREFIX;
  358.         if (codeNamespaces && codeNamespaces.length > 0)
  359.         {
  360.             codeNamespaces[0] = "var " + codeNamespaces[0];
  361.             fullCode += codeNamespaces.join("\n") + "\n\n";
  362.         }
  364.         fullCode += code;
  365.         return fullCode;
  366.     }
  368.     apiGetOpCode(req)
  369.     {
  370.         const preview = !!req.query.preview;
  371.         const opName = req.params.opName;
  372.         let code = "";
  373.         const currentProject = settings.getCurrentProject();
  374.         try
  375.         {
  376.             const attachmentOps = opsUtil.getSubPatchOpAttachment(opName);
  377.             const bpOps = subPatchOpUtil.getOpsUsedInSubPatches(attachmentOps);
  379.             if (!bpOps)
  380.             {
  381.                 return code;
  382.             }
  383.             else
  384.             {
  385.                 let opNames = [];
  386.                 for (let i = 0; i < bpOps.length; i++)
  387.                 {
  388.                     const bpOp = bpOps[i];
  389.                     const bpOpName = opsUtil.getOpNameById(bpOp.opId);
  390.                     if (opsUtil.isCoreOp(bpOpName) && (!opsUtil.isOpOldVersion(bpOpName) && !opsUtil.isDeprecated(bpOpName))) continue;
  391.                     if (currentProject && currentProject.ops && currentProject.ops.some((projectOp) => { return projectOp.opId === bpOp.opId; })) continue;
  392.                     opNames.push(bpOpName);
  393.                 }
  395.                 if (opsUtil.isExtension(opName) || opsUtil.isTeamNamespace(opName))
  396.                 {
  397.                     const collectionName = opsUtil.getCollectionNamespace(opName);
  398.                     opNames = opNames.concat(opsUtil.getCollectionOpNames(collectionName));
  399.                     opNames.push(opName);
  400.                 }
  401.                 else
  402.                 {
  403.                     opNames.push(opName);
  404.                 }
  406.                 const ops = [];
  407.                 opNames.forEach((name) =>
  408.                 {
  409.                     ops.push({
  410.                         "objName": name,
  411.                         "opId": opsUtil.getOpIdByObjName(name)
  412.                     });
  413.                 });
  415.                 code = preview ? opsUtil.buildPreviewCode(ops) : opsUtil.buildFullCode(ops, "none");
  416.                 return code;
  417.             }
  418.         }
  419.         catch (e)
  420.         {
  421.             this._log.error("FAILED TO BUILD OPCODE FOR", opName, e);
  422.             return code;
  423.         }
  424.     }
  426.     apiGetCoreLibs(req)
  427.     {
  428.         const name = req.params.name;
  429.         const fn = path.join(cables.getCoreLibsPath(), name + ".js");
  431.         if (fs.existsSync(fn))
  432.         {
  433.             return fs.readFileSync(fn);
  434.         }
  435.         else
  436.         {
  437.             this._log.error("COULD NOT FIND CORELIB FILE AT", fn);
  438.             return "";
  439.         }
  440.     }
  442.     apiGetLibs(req)
  443.     {
  444.         const name = req.params.name;
  445.         const fn = path.join(cables.getLibsPath(), name);
  446.         if (fs.existsSync(fn))
  447.         {
  448.             return fs.readFileSync(fn);
  449.         }
  450.         else
  451.         {
  452.             this._log.error("COULD NOT FIND LIB FILE AT", fn);
  453.             return "";
  454.         }
  455.     }
  457.     apiGetChangelog()
  458.     {
  459.         return {
  460.             "ts": Date.now(),
  461.             "items": []
  462.         };
  463.     }
  465.     apiOpLayout(req)
  466.     {
  467.         const opName = req.params.opName;
  468.         return opsUtil.getOpSVG(opName);
  469.     }
  471.     _addDefaultHeaders(request, response, existingFile)
  472.     {
  473.         try
  474.         {
  475.             const stats = fs.statSync(existingFile);
  476.             if (stats)
  477.             {
  478.                 response.headers.append("Accept-Ranges", "bytes");
  479.                 response.headers.append("Last-Modified", stats.mtime.toUTCString());
  481.                 // large mp4 and range headers cause problems somehow...
  482.                 // https://github.com/laurent22/joplin/blob/e607a7376f8403082e87087a3e07f37cb2e1ce76/packages/app-desktop/utils/customProtocols/handleCustomProtocols.ts#L106
  483.                 const rangeHeader = request.headers.get("Range");
  484.                 const startByte = Number(rangeHeader.match(/(\d+)-/)?.[1] || "0");
  485.                 const endByte = Number(rangeHeader.match(/-(\d+)/)?.[1] || stats.size - 1);
  486.                 response.headers.append("Content-Range", "bytes 0-" + stats.size + "/" + (stats.size + 1));
  487.                 response.headers.append("Content-Length", (endByte + 1) - startByte);
  488.             }
  489.             let mimeType = mime.getType(existingFile);
  490.             if (mimeType)
  491.             {
  492.                 if (mimeType === "application/node") mimeType = "text/javascript";
  493.                 response.headers.set("Content-Type", mimeType);
  494.             }
  495.         }
  496.         catch (e) {}
  497.         return response;
  498.     }
  499. }
  501. export default new ElectronEndpoint();