anbaric-web 1.21.0

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "anbaric-web",
+  "version": "1.21.0",
+  "description": "Shared platform web utilities: the app-proxy URL helpers and a safely-pooled Postgres client for plugin data functions",
+  "license": "MIT",
+  "author": "chris@anbaric.ai",
+  "type": "module",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "scripts": {
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "pg": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "@types/pg": "^8.15.0",
+    "typescript": "^7.0.2"
+  },
+  "files": [
+    "src"
+  ]
+}

package/src/appInternalPath.ts

@@ -0,0 +1,56 @@
+/* The app-proxy URL convention, in one place. A Node app deployed under
+   /app/<name> is served with that prefix stripped, so an absolute-path URL it
+   emits - a sub-page like "/orders", a resource like "/styles.css", or an Await
+   resolveUrl like "/approve?job=1" - points at the platform root rather than the
+   app. These helpers map such a path back onto its app at /app/<name>/<path>.
+
+   The core conditional rewrite - appInternalPath - is shared by both uses: the
+   server's Referer-based link recovery derives the app name from the Referer,
+   while a plugin presenting an Await resolveUrl supplies it directly (the app is
+   known from the job's app_id). Keeping the rule here means both agree on what
+   "an app-internal absolute path" is and how it maps onto /app/<name>. */
+
+const KNOWN_PREFIXES = ["/api", "/app"];
+
+const isKnownPrefix = (pathname : string) : boolean =>
+    KNOWN_PREFIXES.some(prefix => pathname === prefix || pathname.startsWith(`${prefix}/`));
+
+/* Places an absolute path onto the named app at /app/<appName>/<path>, or
+   returns undefined (leave the path untouched) when there is no app, the path
+   is not absolute (a relative or fully-qualified URL), or it is already under a
+   known platform prefix (/api, /app - including an already-correct /app/... ). */
+const appInternalPath = (appName : string | undefined, pathname : string, search : string = "") : string | undefined => {
+    if (!appName) return undefined;
+    if (!pathname.startsWith("/")) return undefined;
+    if (isKnownPrefix(pathname)) return undefined;
+    return `/app/${appName}${pathname}${search}`;
+};
+
+/* The same rule for a whole URL string (path plus any query/hash), returning the
+   rewritten URL, or the original unchanged when it should be left alone. Use
+   this where a URL is presented rather than routed - e.g. an Await resolveUrl. */
+const appInternalUrl = (appName : string | undefined, url : string) : string => {
+    const separator = url.search(/[?#]/);
+    const pathname = separator === -1 ? url : url.slice(0, separator);
+    const search = separator === -1 ? "" : url.slice(separator);
+    return appInternalPath(appName, pathname, search) ?? url;
+};
+
+const refererAppName = (referer : string | undefined) : string | undefined => {
+    if (!referer) return undefined;
+
+    let pathname : string;
+    try {
+        pathname = new URL(referer).pathname;
+    } catch {
+        pathname = referer;
+    }
+
+    const match = /^\/app\/([^/?#]+)(?:[/?#]|$)/.exec(pathname);
+    return match ? match[1] : undefined;
+};
+
+const appInternalRedirect = (pathname : string, search : string, referer : string | undefined) : string | undefined =>
+    appInternalPath(refererAppName(referer), pathname, search);
+
+export { appInternalPath, appInternalUrl, appInternalRedirect, refererAppName };

package/src/database.ts

@@ -0,0 +1,12 @@
+import { Pool } from "pg";
+
+/* A single lazily-created connection pool to the platform database, shared
+   across every plugin data call in the process. Data functions run on the
+   server; in a plugin's browser bundle pg is stubbed and this is never reached.
+   Centralising it here means plugins never hand-roll their own Pool (and never
+   leak one per call). */
+let pool : Pool | undefined;
+
+const database = () : Pool => (pool ??= new Pool({ connectionString: process.env.ANBARIC_DATABASE_URL }));
+
+export { database };

package/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./appInternalPath";
+export * from "./database";