@witchcraft/nuxt-electron 0.2.2 → 0.2.3

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "electron",
   "configKey": "electron",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/electron/createProxiedProtocolHandler.d.ts

@@ -1,4 +1,6 @@
 import type { Protocol } from "electron";
+export declare const cache: Map<string, string | undefined>;
+export declare const proxyCache: Map<string, string | undefined>;
 export declare function createProxiedProtocolHandler(
 /** `protocol` or `session.protocol` depending on if you're using paritions with your windows or not, regular `protocol` only registers the handler for the default parition. */
 protocol: Protocol, protocolName: string | undefined, basePath: string, 
@@ -7,14 +9,33 @@ protocol: Protocol, protocolName: string | undefined, basePath: string,
  *
  * At least `/api` should be added for a basic nuxt app to work correctly.
  *
+ * The longest key matched will be used.
  *
  * ```ts
  * routeProxies: {
- * 	"/api": "http://localhost:3000/api",
+ * 	"/api": "http://localhost:3000", // turns into http://localhost:3000/api
+ * 	// for more control, for example: to proxy /your/path to some other path while removing the /your/path part:
+ * 	"/your/path": {
+ * 		url: "http://some-site.com",
+ * 		convertPath: (proxyKey, url, requestPath) => url + requestPath.slice(proxyKey.length)
+ * 	}
+ * 	// to ignore a path
+ * 	"/ignore/some/path": {
+ * 		ignore: true
+ * 	}
  * }
  * ```
  */
-routeProxies: Record<string, string>, { logger, errorPage }?: {
+routeProxies: Record<string, string | {
+    url: string;
+    /** Override how the path is merged with the url. The default literally just concatenates url + path. */
+    convertPath?: (proxyKey: string, url: string, requestPath: string) => string;
+    ignore?: false;
+} | {
+    url: never;
+    convertPath: never;
+    ignore: true;
+}>, { logger, errorPage }?: {
     /**
      * Optional logger. It's suggested you not pass this unless you're traceging in dev mode as a lot of requests can be made.
      */

package/dist/runtime/electron/createProxiedProtocolHandler.js

@@ -4,33 +4,41 @@ import { net } from "electron";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-const cache = /* @__PURE__ */ new Map();
-async function getPathToServe(originalPath, pathWithIndexHtml, key, logger) {
-  if (cache.has(key)) {
-    const result = cache.get(key);
-    if (logger) {
-      logger.trace({
-        ns: "main:createProxiedProtocolHandler:cacheHit",
-        requestUrl: key,
-        result: cache.get(key)
-      });
-    }
-    return result;
-  }
+export const cache = /* @__PURE__ */ new Map();
+export const proxyCache = /* @__PURE__ */ new Map();
+const proxiedProperties = ["headers", "destination", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive"];
+async function getPathToServe(originalPath, pathWithIndexHtml, requestUrl, logger) {
   const stats = await fs.stat(originalPath).catch(() => void 0);
   if (logger) {
     logger.trace({
       ns: "main:createProxiedProtocolHandler:stats",
-      key,
+      requestUrl,
       exists: !!stats,
       isFile: stats?.isFile(),
       isDirectory: stats?.isDirectory()
     });
   }
   const pathToServe = stats !== void 0 ? stats.isFile() ? originalPath : stats.isDirectory() ? (await fs.stat(pathWithIndexHtml).catch(() => void 0))?.isFile() ? pathWithIndexHtml : void 0 : void 0 : void 0;
-  cache.set(key, pathToServe);
   return pathToServe;
 }
+async function getFromCacheOr(cache2, key, fn, logger) {
+  let result = cache2.get(key);
+  if (result) {
+    if (logger) {
+      logger.trace({
+        ns: "main:createProxiedProtocolHandler:cacheHit",
+        requestUrl: key,
+        result
+      });
+    }
+    return result;
+  }
+  result = await fn(key);
+  if (result) {
+    cache2.set(key, result);
+  }
+  return result;
+}
 export function createProxiedProtocolHandler(protocol, protocolName = "app", basePath, routeProxies, {
   logger,
   errorPage = "404.html"
@@ -46,28 +54,44 @@ export function createProxiedProtocolHandler(protocol, protocolName = "app", bas
   }
   let errorPage404;
   protocol.handle(protocolName, async (request) => {
-    errorPage404 ??= await getPathToServe(path.join(basePath, errorPage), "404.html", "404.html", logger);
+    errorPage404 ??= await getFromCacheOr(cache, "404.html", (key) => getPathToServe(path.join(basePath, errorPage), "404.html", key, logger), logger);
     if (!errorPage404) {
       throw new Error(`Error page ${path.join(basePath, errorPage)} does not exist. Did you override the routeRules for it?`);
     }
     const parsedUrl = new URL(request.url);
     const requestPath = decodeURIComponent(parsedUrl.pathname);
-    const proxyKey = routeProxyKeys.find((key) => requestPath.startsWith(key));
-    if (proxyKey) {
-      const proxyUrl = routeProxies[proxyKey];
-      const finalPath2 = proxyUrl + requestPath;
+    const cachedProxyResult = await getFromCacheOr(proxyCache, requestPath, (_) => {
+      const matchedProxyKeys = routeProxyKeys.filter((key) => requestPath.startsWith(key));
+      const proxyKey = matchedProxyKeys.sort((a, b) => b.length - a.length)[0];
+      const proxyEntry = proxyKey && routeProxies[proxyKey];
+      if (proxyKey && proxyEntry && !(typeof proxyEntry === "object" && proxyEntry?.ignore)) {
+        const proxyUrl = typeof proxyEntry === "string" ? proxyEntry : proxyEntry?.url;
+        const finalPath2 = typeof proxyEntry === "object" && proxyEntry?.convertPath ? proxyEntry.convertPath(proxyKey, proxyUrl, requestPath) : proxyUrl + requestPath;
+        if (logger) {
+          logger.trace({
+            ns: "main:createProxiedProtocolHandler:fetchingViaProxy",
+            requestUrl: request.url,
+            proxyKey,
+            route: proxyUrl,
+            requestPath,
+            finalPath: finalPath2
+          });
+        }
+        return finalPath2;
+      }
+      return void 0;
+    });
+    if (cachedProxyResult) {
       if (logger) {
         logger.trace({
-          ns: "main:createProxiedProtocolHandler:fetchingViaProxy",
+          ns: "main:createProxiedProtocolHandler:fetchingViaProxy(cached)",
           requestUrl: request.url,
-          proxyKey,
-          route: proxyUrl,
           requestPath,
-          finalPath: finalPath2
+          finalPath: cachedProxyResult
         });
       }
-      return net.fetch(finalPath2, {
-        ...pick(request, ["headers", "destination", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive"])
+      return net.fetch(cachedProxyResult, {
+        ...pick(request, proxiedProperties)
       });
     }
     const originalPath = path.join(basePath, requestPath);
@@ -107,7 +131,7 @@ export function createProxiedProtocolHandler(protocol, protocolName = "app", bas
         status: 400
       });
     }
-    const pathToServe = await getPathToServe(originalPath, pathWithIndexHtml, request.url, logger);
+    const pathToServe = await getFromCacheOr(cache, request.url, (key) => getPathToServe(originalPath, pathWithIndexHtml, key, logger), logger);
     if (!pathToServe) {
       if (logger) {
         logger.error({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@witchcraft/nuxt-electron",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Nuxt module for working with electron.",
   "repository": "https://github.com/witchcraftjs/nuxt-electron",
   "license": "MIT",

package/src/runtime/electron/createProxiedProtocolHandler.ts

@@ -7,35 +7,24 @@ import path from "node:path"
 import { pathToFileURL } from "node:url"
 
 
-const cache = new Map<string, string | undefined>()
+export const cache = new Map<string, string | undefined>()
+export const proxyCache = new Map<string, string | undefined>()
+const proxiedProperties: (keyof Request)[] = ["headers", "destination", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive"]
 
 async function getPathToServe(
 	originalPath: string,
 	pathWithIndexHtml: string,
-	/** Usually the request url */
-	key: string,
+	requestUrl: string,
 	logger?: {
 		trace: (...args: any[]) => void
 	}
 ) {
-	if (cache.has(key)) {
-		const result = cache.get(key)
-		if (logger) {
-			logger.trace({
-				ns: "main:createProxiedProtocolHandler:cacheHit",
-				requestUrl: key,
-				result: cache.get(key)
-			})
-		}
-		return result
-	}
 	const stats = await fs.stat(originalPath).catch(() => undefined)
 
-
 	if (logger) {
 		logger.trace({
 			ns: "main:createProxiedProtocolHandler:stats",
-			key,
+			requestUrl,
 			exists: !!stats,
 			isFile: stats?.isFile(),
 			isDirectory: stats?.isDirectory()
@@ -51,9 +40,28 @@ async function getPathToServe(
 						: undefined
 				: undefined
 		: undefined
-	cache.set(key, pathToServe)
 	return pathToServe
 }
+
+async function getFromCacheOr(cache: Map<string, string | undefined>, key: string, fn: (key: string) => Promise<string | undefined> | string | undefined, logger?: {	trace: (...args: any[]) => void }): Promise<string | undefined> {
+	let result = cache.get(key)
+	if (result) {
+		if (logger) {
+			logger.trace({
+				ns: "main:createProxiedProtocolHandler:cacheHit",
+				requestUrl: key,
+				result
+			})
+		}
+		return result
+	}
+	result = await fn(key)
+	if (result) {
+		cache.set(key, result)
+	}
+	return result
+}
+
 export function createProxiedProtocolHandler(
 	/** `protocol` or `session.protocol` depending on if you're using paritions with your windows or not, regular `protocol` only registers the handler for the default parition. */
 	protocol: Protocol,
@@ -64,14 +72,38 @@ export function createProxiedProtocolHandler(
 	 *
 	 * At least `/api` should be added for a basic nuxt app to work correctly.
 	 *
+	 * The longest key matched will be used.
 	 *
 	 * ```ts
 	 * routeProxies: {
-	 * 	"/api": "http://localhost:3000/api",
+	 * 	"/api": "http://localhost:3000", // turns into http://localhost:3000/api
+	 * 	// for more control, for example: to proxy /your/path to some other path while removing the /your/path part:
+	 * 	"/your/path": {
+	 * 		url: "http://some-site.com",
+	 * 		convertPath: (proxyKey, url, requestPath) => url + requestPath.slice(proxyKey.length)
+	 * 	}
+	 * 	// to ignore a path
+	 * 	"/ignore/some/path": {
+	 * 		ignore: true
+	 * 	}
 	 * }
 	 * ```
 	 */
-	routeProxies: Record<string, string>,
+	routeProxies: Record<
+		string,
+		| string
+		| {
+			url: string
+			/** Override how the path is merged with the url. The default literally just concatenates url + path. */
+			convertPath?: (proxyKey: string, url: string, requestPath: string) => string
+			ignore?: false
+		}
+		|	{
+			url: never
+			convertPath: never
+			ignore: true
+		}
+	>,
 	{
 		logger,
 		errorPage = "404.html"
@@ -108,7 +140,7 @@ export function createProxiedProtocolHandler(
 	// to check the user correctly registered it
 	// it's deprecated for some reason and also it doesn't work (so maybe because of that)!
 	protocol.handle(protocolName, async request => {
-		errorPage404 ??= await getPathToServe(path.join(basePath, errorPage), "404.html", "404.html", logger)
+		errorPage404 ??= await getFromCacheOr(cache, "404.html", key => getPathToServe(path.join(basePath, errorPage), "404.html", key, logger), logger)
 
 		if (!errorPage404) {
 			throw new Error(`Error page ${path.join(basePath, errorPage)} does not exist. Did you override the routeRules for it?`)
@@ -118,23 +150,45 @@ export function createProxiedProtocolHandler(
 		// we can ignore the host, as getPaths sets it to bundle (e.g. protocol://bundle/path/to/file)
 		const requestPath = decodeURIComponent(parsedUrl.pathname)
 
-		const proxyKey = routeProxyKeys.find(key => requestPath.startsWith(key))
 
-		if (proxyKey) {
-			const proxyUrl = routeProxies[proxyKey]
-			const finalPath = proxyUrl + requestPath
+		// this must be on a seperate cache because the result and key are different since fetching is different
+		const cachedProxyResult = await getFromCacheOr(proxyCache, requestPath, _ /* requestPath */ => {
+			const matchedProxyKeys = routeProxyKeys.filter(key => requestPath.startsWith(key))
+			const proxyKey = matchedProxyKeys.sort((a, b) => b.length - a.length)[0]
+
+			const proxyEntry = proxyKey && routeProxies[proxyKey]
+			if (proxyKey && proxyEntry && !(typeof proxyEntry === "object" && proxyEntry?.ignore)) {
+				const proxyUrl = typeof proxyEntry === "string" ? proxyEntry : proxyEntry?.url
+
+				const finalPath = typeof proxyEntry === "object" && proxyEntry?.convertPath
+					? proxyEntry.convertPath(proxyKey, proxyUrl, requestPath)
+					: proxyUrl + requestPath
+
+				if (logger) {
+					logger.trace({
+						ns: "main:createProxiedProtocolHandler:fetchingViaProxy",
+						requestUrl: request.url,
+						proxyKey,
+						route: proxyUrl,
+						requestPath,
+						finalPath
+					})
+				}
+				return finalPath
+			}
+			return undefined
+		})
+		if (cachedProxyResult) {
 			if (logger) {
 				logger.trace({
-					ns: "main:createProxiedProtocolHandler:fetchingViaProxy",
+					ns: "main:createProxiedProtocolHandler:fetchingViaProxy(cached)",
 					requestUrl: request.url,
-					proxyKey,
-					route: proxyUrl,
 					requestPath,
-					finalPath
+					finalPath: cachedProxyResult
 				})
 			}
-			return net.fetch(finalPath, {
-				...pick(request, ["headers", "destination", "referrer", "referrerPolicy", "mode", "credentials", "cache", "redirect", "integrity", "keepalive"])
+			return net.fetch(cachedProxyResult, {
+				...pick(request, proxiedProperties)
 			})
 		}
 
@@ -173,7 +227,7 @@ export function createProxiedProtocolHandler(
 		}
 
 
-		const pathToServe = await getPathToServe(originalPath, pathWithIndexHtml, request.url, logger)
+		const pathToServe = await getFromCacheOr(cache, request.url, key => getPathToServe(originalPath, pathWithIndexHtml, key, logger), logger)
 
 		if (!pathToServe) {
 			if (logger) {