@joystick.js/node-canary 0.0.0-canary.33 → 0.0.0-canary.331

package/dist/app/databases/queryMap.js

@@ -1,15 +1,19 @@
 import mongodbAccountsQueries from "./mongodb/queries/accounts";
 import mongodbQueuesQueries from "./mongodb/queries/queues";
+import mongodbSessionsQueries from "./mongodb/queries/sessions";
 import postgresqlAccountsQueries from "./postgresql/queries/accounts";
 import postgresqlQueuesQueries from "./postgresql/queries/queues";
+import postgresqlSessionsQueries from "./postgresql/queries/sessions";
 var queryMap_default = {
   mongodb: {
     accounts: mongodbAccountsQueries,
-    queues: mongodbQueuesQueries
+    queues: mongodbQueuesQueries,
+    sessions: mongodbSessionsQueries
   },
   postgresql: {
     accounts: postgresqlAccountsQueries,
-    queues: postgresqlQueuesQueries
+    queues: postgresqlQueuesQueries,
+    sessions: postgresqlSessionsQueries
   }
 };
 export {

package/dist/app/databases/stringToSnakeCase.js

@@ -0,0 +1,6 @@
+var stringToSnakeCase_default = (string = "") => {
+  return string?.split(/\.?(?=[A-Z])/).join("_").toLowerCase();
+};
+export {
+  stringToSnakeCase_default as default
+};

package/dist/app/getBrowserSafeRequest.js

@@ -1,8 +1,9 @@
 import getBrowserSafeUser from "./accounts/getBrowserSafeUser";
+import escapeKeyValuePair from "../lib/escapeKeyValuePair.js";
 var getBrowserSafeRequest_default = (req = {}) => {
   const browserSafeRequest = {};
-  browserSafeRequest.params = req.params;
-  browserSafeRequest.query = req.query;
+  browserSafeRequest.params = escapeKeyValuePair(req.params);
+  browserSafeRequest.query = escapeKeyValuePair(req.query);
   browserSafeRequest.context = {
     user: getBrowserSafeUser(req.context.user)
   };

package/dist/app/index.js

@@ -6,6 +6,8 @@ import queryString from "query-string";
 import multer from "multer";
 import cron from "node-cron";
 import { execSync } from "child_process";
+import dayjs from "dayjs";
+import cluster from "./cluster.js";
 import initExpress from "./initExpress.js";
 import handleProcessErrors from "./handleProcessErrors";
 import registerGetters from "./registerGetters.js";
@@ -25,49 +27,58 @@ import runUploader from "./runUploader";
 import generateId from "../lib/generateId.js";
 import getOutput from "./getOutput.js";
 import defaultUserOutputFields from "./accounts/defaultUserOutputFields.js";
+import createMongoDBAccountsIndexes from "./databases/mongodb/createAccountsIndexes";
+import createMongoDBSessionsIndexes from "./databases/mongodb/createSessionsIndexes";
 import createPostgreSQLAccountsTables from "./databases/postgresql/createAccountsTables";
 import createPostgreSQLAccountsIndexes from "./databases/postgresql/createAccountsIndexes";
+import createPostgreSQLSessionsTables from "./databases/postgresql/createSessionsTables";
+import createPostgreSQLSessionsIndexes from "./databases/postgresql/createSessionsIndexes";
 import loadSettings from "../settings/load.js";
 import Queue from "./queues/index.js";
 import readDirectory from "../lib/readDirectory.js";
 import getBuildPath from "../lib/getBuildPath.js";
 import generateMachineId from "../lib/generateMachineId.js";
+import importFile from "../lib/importFile.js";
 import emitWebsocketEvent from "../websockets/emitWebsocketEvent.js";
 import getTargetDatabaseConnection from "./databases/getTargetDatabaseConnection.js";
+import getAPIForDataFunctions from "../ssr/getAPIForDataFunctions.js";
+import getBrowserSafeRequest from "./getBrowserSafeRequest.js";
+import getDataFromComponent from "../ssr/getDataFromComponent.js";
+import getTranslations from "./middleware/getTranslations.js";
+import runUserQuery from "./accounts/runUserQuery.js";
+import wait from "../lib/wait.js";
+import trackFunctionCall from "../test/trackFunctionCall.js";
+import getBrowserSafeUser from "./accounts/getBrowserSafeUser.js";
 process.setMaxListeners(0);
 class App {
   constructor(options = {}) {
     this.setMachineId();
     this.setJoystickProcessId();
     handleProcessErrors(options?.events);
-    const HMRSessions = JSON.parse(process.env.HMR_SESSIONS || "{}");
-    this.sessions = new Map(HMRSessions ? Object.entries(HMRSessions) : []);
     this.databases = [];
     this.express = {};
     this.options = options || {};
+    process.joystick = {
+      _app: {
+        options
+      }
+    };
   }
   async start(options = {}) {
     await this.invalidateCache();
     this.databases = await this.loadDatabases();
     this.express = initExpress(this.onStartApp, options, this);
     this.initWebsockets(options?.websockets || {});
-    this.initDevelopmentRoutes();
-    this.initAccounts();
-    this.initDeploy();
+    this.initAccounts(options?.accounts);
+    this.initTests();
+    this.initPush();
     this.initAPI(options?.api);
-    this.initRoutes(options?.routes);
     this.initUploaders(options?.uploaders);
+    this.initIndexes(options?.indexes);
     this.initFixtures(options?.fixtures);
     this.initQueues(options?.queues);
     this.initCronJobs(options?.cronJobs);
-    if (process.env.NODE_ENV === "development") {
-      process.on("message", (message) => {
-        const parsedMessage = typeof message === "string" ? JSON.parse(message) : message;
-        if (parsedMessage?.type === " RESTART_SERVER") {
-          this.express?.server?.close();
-        }
-      });
-    }
+    this.initRoutes(options?.routes);
   }
   async invalidateCache() {
     const uiFiles = fs.existsSync(`${getBuildPath()}ui`) ? await readDirectory(`${getBuildPath()}ui`) : [];
@@ -85,9 +96,21 @@ class App {
     const hasQueuesDatabase = settings?.config?.databases?.some((database = {}) => {
       return !!database?.queues;
     });
+    const hasSessionsDatabase = settings?.config?.databases?.some((database = {}) => {
+      return !!database?.sessions;
+    });
+    const hasMongoDBUsersDatabase = settings?.config?.databases?.some((database = {}) => {
+      return database?.provider === "mongodb" && database?.users;
+    });
+    const hasMongoDBSessionsDatabase = settings?.config?.databases?.some((database = {}) => {
+      return database?.provider === "mongodb" && database?.sessions;
+    });
     const hasPostgreSQLUsersDatabase = settings?.config?.databases?.some((database = {}) => {
       return database?.provider === "postgresql" && database?.users;
     });
+    const hasPostgreSQLSessionsDatabase = settings?.config?.databases?.some((database = {}) => {
+      return database?.provider === "postgresql" && database?.sessions;
+    });
     const databases = settings?.config?.databases?.map((database) => {
       return {
         provider: database?.provider,
@@ -114,12 +137,22 @@ class App {
           ...process.databases || {},
           postgresql: !hasMultipleOfProvider ? {
             ...postgresql?.pool,
-            query: postgresql?.query
+            add_column: postgresql?.add_column,
+            create_table: postgresql?.create_table,
+            insert: postgresql?.insert,
+            query: postgresql?.query,
+            select: postgresql?.select,
+            update: postgresql?.update
           } : {
             ...process?.databases?.postgresql || {},
             [database?.settings?.name || `postgresql_${databasePort}`]: {
               ...postgresql?.pool,
-              query: postgresql?.query
+              add_column: postgresql?.add_column,
+              create_table: postgresql?.create_table,
+              insert: postgresql?.insert,
+              query: postgresql?.query,
+              select: postgresql?.select,
+              update: postgresql?.update
             }
           }
         };
@@ -131,19 +164,40 @@ class App {
     if (hasQueuesDatabase) {
       process.databases._queues = getTargetDatabaseConnection("queues")?.connection;
     }
+    if (hasSessionsDatabase) {
+      process.databases._sessions = getTargetDatabaseConnection("sessions")?.connection;
+    }
+    if (hasMongoDBUsersDatabase) {
+      await createMongoDBAccountsIndexes();
+    }
+    if (hasMongoDBSessionsDatabase) {
+      await createMongoDBSessionsIndexes();
+    }
     if (hasPostgreSQLUsersDatabase) {
       await createPostgreSQLAccountsTables();
       await createPostgreSQLAccountsIndexes();
     }
+    if (hasPostgreSQLSessionsDatabase) {
+      await createPostgreSQLSessionsTables();
+      await createPostgreSQLSessionsIndexes();
+    }
     return process.databases;
   }
-  onStartApp(express = {}) {
+  onStartApp(express = {}, joystick_app_instance = {}) {
     process.on("message", (message) => {
       if (typeof message === "string") {
-        process.BUILD_ERROR = JSON.parse(message);
+        const parsed_message = JSON.parse(message);
+        if (parsed_message?.type === "BUILD_ERROR") {
+          process.BUILD_ERROR = JSON.parse(message);
+        }
+        if (parsed_message?.type === "RESTART_SERVER") {
+          console.log("HANDLE RESTART");
+        }
       }
     });
-    console.log(`App running at: http://localhost:${express.port}`);
+    if (process.env.NODE_ENV !== "test") {
+      console.log(`App running at: http://localhost:${express.port}`);
+    }
   }
   setMachineId() {
     generateMachineId();
@@ -156,10 +210,78 @@ class App {
       fs.writeFileSync("./.joystick/PROCESS_ID", `${generateId(32)}`);
     }
   }
-  initDeploy() {
-    if (process.env.NODE_ENV === "production" && process.env.IS_PUSH_DEPLOYED) {
+  initTests() {
+    if (process.env.NODE_ENV === "test") {
+      this.express.app.get("/api/_test/bootstrap", async (req, res) => {
+        const buildPath = `${process.cwd()}/.joystick/build`;
+        const Component = req?.query?.pathToComponent ? await importFile(`${buildPath}/${req?.query?.pathToComponent}`) : null;
+        if (Component) {
+          const componentInstance = Component();
+          const apiForDataFunctions = await getAPIForDataFunctions(req, this?.options?.api);
+          const browserSafeRequest = getBrowserSafeRequest(req);
+          const browserSafeUser = getBrowserSafeUser(req?.context?.user);
+          const data = await getDataFromComponent(componentInstance, apiForDataFunctions, browserSafeUser, browserSafeRequest);
+          const translations = await getTranslations({ build: buildPath, page: req?.query?.pathToComponent }, req);
+          const settings = loadSettings();
+          return res.status(200).send({
+            data: {
+              [data?.componentId]: data?.data
+            },
+            req: browserSafeRequest,
+            settings,
+            translations
+          });
+        }
+        res.status(200).send({ data: {}, translations: {} });
+      });
+      this.express.app.get("/api/_test/process", async (req, res) => {
+        res.status(200).send({
+          test: process?.test || {}
+        });
+      });
+      this.express.app.post("/api/_test/accounts/signup", async (req, res) => {
+        const existingUser = await runUserQuery("user", { emailAddress: req?.body?.emailAddress });
+        if (existingUser) {
+          await runUserQuery("deleteUser", { userId: existingUser?._id || existingUser?.user_id });
+        }
+        const signup = await accounts.signup({
+          emailAddress: req?.body?.emailAddress,
+          password: req?.body?.password,
+          metadata: req?.body?.metadata,
+          output: req?.body?.output || defaultUserOutputFields
+        });
+        res.status(200).send(JSON.stringify({
+          ...signup?.user || {},
+          joystickLoginToken: signup?.token,
+          joystickLoginTokenExpiresAt: signup?.tokenExpiresAt
+        }));
+      });
+      this.express.app.delete("/api/_test/accounts", async (req, res) => {
+        await runUserQuery("deleteUser", { userId: req?.body?.userId });
+        res.status(200).send({ data: {} });
+      });
+      this.express.app.post("/api/_test/queues", async (req, res) => {
+        const queue = process?.queues[req?.body?.queue];
+        const job = this?.options?.queues[req?.body?.queue]?.jobs[req?.body?.job];
+        if (!queue) {
+          return res.status(404).send({ status: 404, error: `Queue ${req?.body?.queue} not found.` });
+        }
+        if (!job) {
+          return res.status(400).send({ status: 400, error: `Couldn't find a job called ${req?.body?.job} for the ${req?.body?.queue} queue.` });
+        }
+        await queue.handleNextJob({
+          _id: "joystick_test",
+          job: req?.body?.job,
+          payload: req?.body?.payload
+        });
+        res.status(200).send({ data: {} });
+      });
+    }
+  }
+  initPush() {
+    if (process.env.NODE_ENV !== "development" && process.env.IS_PUSH_DEPLOYED) {
       this.express.app.get("/api/_push/pre-version", async (req, res) => {
-        const instanceToken = fs.readFileSync("/root/token.txt", "utf-8");
+        const instanceToken = fs.readFileSync("/root/push/instance_token.txt", "utf-8");
         if (req?.headers["x-instance-token"] === instanceToken?.replace("\n", "")) {
           if (this.options?.events?.onBeforeDeployment && typeof this.options?.events?.onBeforeDeployment === "function") {
             await this.options.events.onBeforeDeployment(req?.query?.instance || "", req?.query?.version);
@@ -170,28 +292,12 @@ class App {
         return res.status(403).send("Sorry, you must pass a valid instance token to access this endpoint.");
       });
       this.express.app.get("/api/_push/health", async (req, res) => {
-        const instanceToken = fs.readFileSync("/root/token.txt", "utf-8");
+        const instanceToken = fs.readFileSync("/root/push/instance_token.txt", "utf-8");
         if (req?.headers["x-instance-token"] === instanceToken?.replace("\n", "")) {
           return res.status(200).send("ok");
         }
         return res.status(403).send("Sorry, you must pass a valid instance token to access this endpoint.");
       });
-      this.express.app.get("/api/_push/logs", async (req, res) => {
-        const instanceToken = fs.readFileSync("/root/token.txt", "utf-8");
-        if (req?.headers["x-instance-token"] === instanceToken?.replace("\n", "")) {
-          const logs = execSync(`export NODE_ENV=production && instance logs${req?.query?.before ? ` --before ${req?.query?.before}` : ""}${req?.query?.after ? ` --after ${req?.query?.after}` : ""}`);
-          return res.status(200).send(logs);
-        }
-        return res.status(403).send("Sorry, you must pass a valid instance token to access this endpoint.");
-      });
-      this.express.app.get("/api/_push/metrics", async (req, res) => {
-        const instanceToken = fs.readFileSync("/root/token.txt", "utf-8");
-        if (req?.headers["x-instance-token"] === instanceToken?.replace("\n", "")) {
-          const metrics = execSync(`export NODE_ENV=production && instance metrics`);
-          return res.status(200).send(metrics);
-        }
-        return res.status(403).send("Sorry, you must pass a valid instance token to access this endpoint.");
-      });
     }
   }
   initAPI(api = {}) {
@@ -199,15 +305,15 @@ class App {
     const setters = api?.setters;
     const options = api?.options;
     const context = api?.context;
-    if (getters && isObject(getters) && Object.keys(getters).length > 0) {
-      registerGetters(this.express, Object.entries(getters), context, options, this);
+    if (getters && isObject(getters) && Object.keys(getters || {}).length > 0) {
+      registerGetters(this.express, Object.entries(getters || {}), context, options, this);
     }
-    if (setters && isObject(setters) && Object.keys(setters).length > 0) {
-      registerSetters(this.express, Object.entries(setters), context, options, this);
+    if (setters && isObject(setters) && Object.keys(setters || {}).length > 0) {
+      registerSetters(this.express, Object.entries(setters || {}), context, options, this);
     }
   }
   initRoutes(routes = {}) {
-    Object.entries(routes).forEach(([path, callback]) => {
+    Object.entries(routes || {}).forEach(([path, callback]) => {
       const isObjectBasedRoute = path && callback && typeof callback === "object";
       const isFunctionBasedRoute = path && callback && typeof callback === "function";
       const method = callback?.method?.toLowerCase();
@@ -331,20 +437,29 @@ class App {
           path: "/api/_websockets/uploaders"
         })
       },
-      ...Object.entries(userWebsockets).reduce((definitions = {}, [userWebsocketName, userWebsocketDefinition]) => {
+      ...Object.entries(userWebsockets || {}).reduce((definitions = {}, [userWebsocketName, userWebsocketDefinition]) => {
         definitions[userWebsocketName] = {
           server: new WebSocket.WebSocketServer({
             noServer: true,
             path: `/api/_websockets/${userWebsocketName}`
           }),
-          onOpen: userWebsocketDefinition?.onOpen || null,
-          onMessage: userWebsocketDefinition?.onMessage || null,
-          onClose: userWebsocketDefinition?.onClose || null
+          onOpen: (...args) => {
+            trackFunctionCall(`node.websockets.${userWebsocketName}.onOpen`, args);
+            return userWebsocketDefinition?.onOpen ? userWebsocketDefinition?.onOpen(...args) : null;
+          },
+          onMessage: (...args) => {
+            trackFunctionCall(`node.websockets.${userWebsocketName}.onMessage`, args);
+            return userWebsocketDefinition?.onMessage ? userWebsocketDefinition?.onMessage(...args) : null;
+          },
+          onClose: (...args) => {
+            trackFunctionCall(`node.websockets.${userWebsocketName}.onClose`, args);
+            return userWebsocketDefinition?.onClose ? userWebsocketDefinition.onClose(...args) : null;
+          }
         };
         return definitions;
       }, {})
     };
-    Object.entries(websocketServers).forEach(([websocketName, websocketDefinition]) => {
+    Object.entries(websocketServers || {}).forEach(([websocketName, websocketDefinition]) => {
       websocketDefinition.server.on("connection", function connection(websocketConnection, connectionRequest) {
         try {
           const [_path, params] = connectionRequest?.url?.split("?");
@@ -400,18 +515,7 @@ class App {
       }
     });
   }
-  initDevelopmentRoutes() {
-    if (process.env.NODE_ENV === "development") {
-      this.express.app.get("/api/_joystick/sessions", async (req, res) => {
-        const sessions = Array.from(this.sessions.entries())?.reduce((acc = {}, [key, value]) => {
-          acc[key] = value;
-          return acc;
-        }, {});
-        res.status(200).send(JSON.stringify(sessions));
-      });
-    }
-  }
-  initAccounts() {
+  initAccounts(options = {}) {
     this.express.app.get("/api/_accounts/authenticated", async (req, res) => {
       const loginTokenHasExpired = await hasLoginTokenExpired(res, req?.cookies?.joystickLoginToken, req?.cookies?.joystickLoginTokenExpiresAt);
       const status = !loginTokenHasExpired ? 200 : 401;
@@ -431,11 +535,20 @@ class App {
           metadata: req?.body?.metadata,
           output: req?.body?.output || defaultUserOutputFields
         });
-        accounts._setAuthenticationCookie(res, {
-          token: signup?.token,
-          tokenExpiresAt: signup?.tokenExpiresAt
-        });
-        res.status(200).send(JSON.stringify(signup?.user || {}));
+        if (!process.env.NODE_ENV !== "test") {
+          accounts._setAuthenticationCookie(res, {
+            token: signup?.token,
+            tokenExpiresAt: signup?.tokenExpiresAt
+          });
+        }
+        const response = {
+          ...signup?.user || {}
+        };
+        if (process.env.NODE_ENV === "test") {
+          response.joystickToken = signup?.token;
+          response.joystickLoginTokenExpiresAt = signup?.tokenExpiresAt;
+        }
+        res.status(200).send(JSON.stringify(response));
       } catch (exception) {
         console.log(exception);
         return res.status(500).send(JSON.stringify({
@@ -451,11 +564,20 @@ class App {
           password: req?.body?.password,
           output: req?.body?.output || defaultUserOutputFields
         });
-        accounts._setAuthenticationCookie(res, {
-          token: login?.token,
-          tokenExpiresAt: login?.tokenExpiresAt
-        });
-        res.status(200).send(JSON.stringify(login?.user || {}));
+        if (!process.env.NODE_ENV !== "test") {
+          accounts._setAuthenticationCookie(res, {
+            token: login?.token,
+            tokenExpiresAt: login?.tokenExpiresAt
+          });
+        }
+        const response = {
+          ...login?.user || {}
+        };
+        if (process.env.NODE_ENV === "test") {
+          response.joystickToken = login?.token;
+          response.joystickLoginTokenExpiresAt = login?.tokenExpiresAt;
+        }
+        res.status(200).send(JSON.stringify(response));
       } catch (exception) {
         console.log(exception);
         return res.status(500).send(JSON.stringify({
@@ -465,8 +587,10 @@ class App {
     });
     this.express.app.post("/api/_accounts/logout", async (req, res) => {
       try {
-        this.sessions.delete(req?.context?.user?._id || req?.context?.user?.user_id);
         accounts._unsetAuthenticationCookie(res);
+        if (typeof options?.onLogout === "function") {
+          options.onLogout(req?.context?.user);
+        }
         res.status(200).send(JSON.stringify({}));
       } catch (exception) {
         console.log(exception);
@@ -523,7 +647,7 @@ class App {
   }
   initUploaders(uploaders = {}) {
     const { app } = this.express;
-    Object.entries(uploaders).forEach(([uploaderName, uploaderOptions]) => {
+    Object.entries(uploaders || {}).forEach(([uploaderName, uploaderOptions]) => {
       const errors = validateUploaderOptions(uploaderOptions);
       if (errors?.length > 0) {
         log(errors, {
@@ -561,6 +685,11 @@ class App {
                 req,
                 uploads: validatedUploads
               });
+              trackFunctionCall(`node.uploaders.${uploaderName}.onBeforeUpload`, [{
+                input,
+                req,
+                uploads: validatedUploads
+              }]);
             }
             const fileSize = parseInt(req.headers["content-length"], 10);
             const providers = uploaderOptions?.providers?.includes("local") ? uploaderOptions?.providers.length : uploaderOptions?.providers?.length + 1;
@@ -578,6 +707,11 @@ class App {
                 req,
                 uploads
               });
+              trackFunctionCall(`node.uploaders.${uploaderName}.onAfterUpload`, [{
+                input,
+                req,
+                uploads
+              }]);
             }
             res.status(200).send(JSON.stringify({
               status: 200,
@@ -604,6 +738,11 @@ class App {
       }
     });
   }
+  initIndexes(indexes = null) {
+    if (indexes && typeof indexes === "function") {
+      indexes();
+    }
+  }
   initFixtures(fixtures = null) {
     if (fixtures && typeof fixtures === "function") {
       fixtures();
@@ -611,7 +750,7 @@ class App {
   }
   initQueues(queues = null) {
     if (queues && typeof queues === "object" && !Array.isArray(queues)) {
-      const queueDefinitions = Object.entries(queues);
+      const queueDefinitions = Object.entries(queues || {});
       for (let i = 0; i < queueDefinitions.length; i += 1) {
         const [queueName, queueOptions] = queueDefinitions[i];
         process.queues = {
@@ -623,7 +762,7 @@ class App {
   }
   initCronJobs(cronJobs = null) {
     if (cronJobs && typeof cronJobs === "object" && !Array.isArray(cronJobs)) {
-      const cronJobDefinitions = Object.entries(cronJobs);
+      const cronJobDefinitions = Object.entries(cronJobs || {});
       for (let i = 0; i < cronJobDefinitions.length; i += 1) {
         const [cronJobName, cronJobOptions] = cronJobDefinitions[i];
         if (cronJobOptions?.schedule && cronJobOptions?.run && typeof cronJobOptions?.run === "function") {
@@ -641,11 +780,23 @@ class App {
     }
   }
 }
+;
+const handleStartApp = async (options = {}) => {
+  const app = new App(options);
+  await app.start(options);
+  return app;
+};
 var app_default = (options = {}) => {
   return new Promise(async (resolve) => {
-    const app = new App(options);
-    await app.start(options);
-    return resolve(app.express);
+    if (options?.cluster) {
+      cluster(async () => {
+        const app = await handleStartApp(options);
+        return resolve(app.express);
+      });
+    } else {
+      const app = await handleStartApp(options);
+      return resolve(app.express);
+    }
   });
 };
 export {

package/dist/app/initExpress.js

@@ -29,7 +29,7 @@ var initExpress_default = (onInit = () => {
       server
     };
     if (onInit) {
-      onInit(instance);
+      onInit(instance, appInstance);
     }
     return instance;
   } catch (exception) {

package/dist/app/middleware/csp.js

@@ -27,7 +27,7 @@ var csp_default = (req, res, next, config = null) => {
       directiveDefaults["script-src"].push("'unsafe-eval'");
       directiveDefaults["connect-src"].push("ws:");
     }
-    const directiveNames = Object.keys(directiveDefaults);
+    const directiveNames = Object.keys(directiveDefaults || {});
     for (let i = 0; i < directiveNames?.length; i += 1) {
       const directive = directiveNames[i];
       directiveDefaults[directive] = [
@@ -36,7 +36,7 @@ var csp_default = (req, res, next, config = null) => {
         ...directives[directive] || []
       ];
     }
-    const csp = Object.keys(directiveDefaults).map((source) => {
+    const csp = Object.keys(directiveDefaults || {}).map((source) => {
       return `${source} ${directiveDefaults[source].join(" ")}`;
     })?.join("; ");
     res.setHeader("Content-Security-Policy", csp);

package/dist/app/middleware/getTranslations.js

@@ -0,0 +1,64 @@
+import fs from "fs";
+import importFile from "../../lib/importFile.js";
+import { isObject } from "../../validation/lib/typeValidators.js";
+import settings from "../../settings/index.js";
+const getTranslationsFile = async (languageFilePath = "", paths = "") => {
+  const languageFile = await importFile(`${paths.build}/i18n/${languageFilePath}`);
+  const isValidLanguageFile = languageFile && isObject(languageFile);
+  if (isValidLanguageFile) {
+    const translationsForPage = languageFile[paths.page];
+    return translationsForPage ? translationsForPage : languageFile;
+  }
+  return {};
+};
+const getLanguagePreferenceRegexes = (userLanguage = "", browserLanguages = []) => {
+  let languagePreferences = [];
+  if (userLanguage) {
+    languagePreferences.push(userLanguage);
+  }
+  const filteredBrowserLanguages = browserLanguages?.filter((language) => {
+    return !language?.includes("*");
+  });
+  languagePreferences.push(...filteredBrowserLanguages);
+  languagePreferences.push(settings?.config?.i18n?.defaultLanguage);
+  return languagePreferences?.flatMap((language) => {
+    const variants = [language];
+    if (language?.length === 2) {
+      variants.push(`${language.substring(0, 2)}-`);
+    }
+    if (language?.length > 2) {
+      variants.push(`${language?.split("-")[0]}`);
+      variants.push(`${language?.split("-")[0]}-`);
+    }
+    return variants;
+  })?.map((languageString) => {
+    const lastCharacter = languageString[languageString.length - 1];
+    if (lastCharacter === "-") {
+      return new RegExp(`^${languageString}[A-Z]+.js`, "g");
+    }
+    return new RegExp(`^${languageString}.js`, "g");
+  });
+};
+const parseBrowserLanguages = (languages = "") => {
+  const rawLanguages = languages.split(",");
+  return rawLanguages?.map((rawLanguage) => rawLanguage.split(";")[0]);
+};
+var getTranslations_default = async (paths = {}, req = {}) => {
+  const languageFiles = fs.readdirSync(`${paths.build}/i18n`);
+  const browserLanguages = parseBrowserLanguages(req?.headers["accept-language"]);
+  const languagePreferences = getLanguagePreferenceRegexes(req?.context?.user?.language, browserLanguages);
+  let matchingFile = null;
+  for (let i = 0; i < languagePreferences.length; i += 1) {
+    const languageRegex = languagePreferences[i];
+    const match = languageFiles.find((languageFile) => !!languageFile.match(languageRegex));
+    if (match) {
+      matchingFile = match;
+      break;
+    }
+  }
+  const translationsFile = await getTranslationsFile(matchingFile, paths);
+  return translationsFile;
+};
+export {
+  getTranslations_default as default
+};