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

package/dist/app/runSetter.js

@@ -3,19 +3,31 @@ import formatAPIError from "../lib/formatAPIError.js";
 import { isObject } from "../validation/lib/typeValidators.js";
 import getOutput from "./getOutput.js";
 import sanitizeAPIResponse from "./sanitizeAPIResponse.js";
-const handleRunSetter = async (setterOptions = {}, input = {}, output = {}, context = {}, APIOptions = {}) => {
+import trackFunctionCall from "../test/trackFunctionCall.js";
+import getSanitizedContext from "../../getSanitizedContext.js";
+const handleRunSetter = async (name = "", setterOptions = {}, input = {}, output = {}, context = {}, APIOptions = {}) => {
   try {
     const shouldDisableSanitizationForSetter = setterOptions?.sanitize === false;
     const shouldSanitizeOutput = (setterOptions?.sanitize || APIOptions?.sanitize) === true || isObject(APIOptions?.sanitize || setterOptions?.sanitize);
-    const data = await setterOptions?.set(input, context) || {};
+    const sanitizedContext = getSanitizedContext(context);
+    trackFunctionCall(`node.api.setters.${name}`, [
+      input,
+      sanitizedContext
+    ]);
+    const data = await setterOptions?.set(input, context);
     const response = output ? getOutput(data, output) : data;
     return !shouldDisableSanitizationForSetter && shouldSanitizeOutput ? sanitizeAPIResponse(response, setterOptions?.sanitize || APIOptions?.sanitize) : response;
   } catch (exception) {
     throw new Error(`[runSetter.handleRunSetter] ${exception.message}`);
   }
 };
-const handleRunAuthorization = async (getterOptions = {}, input = {}, context = {}) => {
+const handleRunAuthorization = async (name = "", getterOptions = {}, input = {}, context = {}) => {
   try {
+    const sanitizedContext = getSanitizedContext(context);
+    trackFunctionCall(`node.api.setters.${name}.authorized`, [
+      input,
+      sanitizedContext
+    ]);
     const authorization = await getterOptions?.authorized(input, context);
     if (typeof authorization === "boolean") {
       return authorization;
@@ -77,7 +89,7 @@ const runSetter = async (options, { resolve, reject }) => {
       }
     }
     if (typeof options?.setterOptions?.authorized === "function") {
-      const authorized = await handleRunAuthorization(options?.setterOptions, options?.input, options?.context);
+      const authorized = await handleRunAuthorization(options?.setterName, options?.setterOptions, options?.input, options?.context);
       if (!authorized || typeof authorized === "string") {
         return reject({
           errors: [
@@ -87,7 +99,7 @@ const runSetter = async (options, { resolve, reject }) => {
       }
     }
     if (typeof options?.setterOptions?.set === "function") {
-      const response = await handleRunSetter(options?.setterOptions, options?.input, options?.output, options?.context, options?.APIOptions);
+      const response = await handleRunSetter(options?.setterName, options?.setterOptions, options?.input, options?.output, options?.context, options?.APIOptions);
       return resolve(response);
     }
     resolve();

package/dist/app/sanitizeAPIResponse.js

@@ -9,7 +9,7 @@ const sanitizeAPIResponse = (data = null) => {
     sanitizedData = escapeHTML(sanitizedData)?.trim();
   }
   if (util.isObject(sanitizedData) && !Array.isArray(sanitizedData)) {
-    sanitizedData = Object.entries(sanitizedData)?.reduce((result = {}, [key, value]) => {
+    sanitizedData = Object.entries(sanitizedData || {})?.reduce((result = {}, [key, value]) => {
       result[key] = sanitizeAPIResponse(value);
       return result;
     }, {});

package/dist/app/validateInstanceToken.js

@@ -0,0 +1,16 @@
+import fs from "fs";
+const { readFile } = fs.promises;
+var validateInstanceToken_default = (instance_token_from_headers = "") => {
+  return new Promise(async (resolve, reject) => {
+    const instance_token_from_disk = await readFile("/root/push/instance_token.txt", "utf-8");
+    const is_valid_token = instance_token_from_headers === instance_token_from_disk?.replace("\n", "");
+    if (is_valid_token) {
+      return resolve();
+    } else {
+      reject();
+    }
+  });
+};
+export {
+  validateInstanceToken_default as default
+};

package/dist/app/validateSession.js

@@ -1,8 +1,13 @@
 import formatAPIError from "../lib/formatAPIError.js";
-var validateSession_default = (req = null, res = null, sessions = null) => {
-  const sessionToken = req?.cookies?.joystickSession;
+import runSessionQuery from "./runSessionQuery.js";
+var validateSession_default = async (req = null, res = null) => {
   const csrfToken = req?.headers["x-joystick-csrf"];
-  const session = sessions?.get(sessionToken);
+  const session = await runSessionQuery("get_session", {
+    session_id: req?.cookies?.joystickSession
+  });
+  if (csrfToken === "joystick_test") {
+    return true;
+  }
   if (!session || session && session.csrf !== csrfToken) {
     res.status(403).send(JSON.stringify({
       errors: [formatAPIError(new Error("Unauthorized request."))]

package/dist/app/validateUploaderOptions.js

@@ -20,7 +20,7 @@ const allowedS3Options = [
 ];
 var validateUploaderOptions_default = (options = {}) => {
   const errors = [];
-  const optionNames = Object.keys(options);
+  const optionNames = Object.keys(options || {});
   optionNames.forEach((optionName) => {
     if (!allowedOptions.includes(optionName)) {
       errors.push(`${optionName} is not an allowed uploader option.`);
@@ -33,14 +33,14 @@ var validateUploaderOptions_default = (options = {}) => {
     errors.push(`If an uploader provider is 's3', s3 object must be specified with configuration.`);
   }
   if (options?.provider?.includes("local") && options.local) {
-    Object.keys(options.local).forEach((optionName) => {
+    Object.keys(options.local || {}).forEach((optionName) => {
       if (!allowedLocalOptions.includes(optionName)) {
         errors.push(`local.${optionName} is not an allowed uploader option.`);
       }
     });
   }
   if (options?.provider?.includes("s3") && options.s3) {
-    Object.keys(options.s3).forEach((optionName) => {
+    Object.keys(options.s3 || {}).forEach((optionName) => {
       if (!allowedS3Options.includes(optionName)) {
         errors.push(`s3.${optionName} is not an allowed uploader option.`);
       }

package/dist/app/validateUploads.js

@@ -1,4 +1,5 @@
 import log from "../lib/log";
+import trackFunctionCall from "../test/trackFunctionCall.js";
 const handleCheckUpload = ({
   uploaderName,
   maxSizeInMegabytes,
@@ -49,6 +50,16 @@ const formatUploads = ({
   try {
     return Promise.all(uploads.map(async (upload) => {
       const fileExtension = upload?.mimeType?.split("/").pop();
+      const fileNameIsFunction = typeof uploaderOptions?.fileName === "function";
+      if (fileNameIsFunction) {
+        trackFunctionCall(`node.uploaders.${uploaderName}.fileName`, [{
+          input,
+          fileName: upload?.originalname,
+          fileSize: upload?.size,
+          fileExtension,
+          mimeType: upload?.mimetype
+        }]);
+      }
       return {
         uploaderName,
         providers: uploaderOptions?.providers,
@@ -56,7 +67,7 @@ const formatUploads = ({
         s3: uploaderOptions?.s3,
         maxSizeInMegabytes: typeof uploaderOptions?.maxSizeInMegabytes === "function" ? await uploaderOptions?.maxSizeInMegabytes({ input, upload }) : uploaderOptions?.maxSizeInMegabytes,
         mimeTypes: uploaderOptions?.mimeTypes,
-        fileName: typeof uploaderOptions?.fileName === "function" ? uploaderOptions.fileName({ input, fileName: upload?.originalname, fileSize: upload?.size, fileExtension, mimeType: upload?.mimetype }) : upload?.originalname,
+        fileName: fileNameIsFunction ? uploaderOptions.fileName({ input, fileName: upload?.originalname, fileSize: upload?.size, fileExtension, mimeType: upload?.mimetype }) : upload?.originalname,
         originalFileName: upload?.originalname,
         fileSize: upload?.size,
         mimeType: upload?.mimetype,

package/dist/email/send.js

@@ -7,7 +7,13 @@ import settings from "../settings";
 import validateSMTPSettings from "./validateSMTPSettings";
 import render from "./render";
 import getBuildPath from "../lib/getBuildPath";
-var send_default = async ({ template: templateName, props, base: baseName, ...restOfOptions }) => {
+import trackFunctionCall from "../test/trackFunctionCall.js";
+var send_default = async (args) => {
+  const { template: templateName, props, base: baseName, ...restOfOptions } = args;
+  if (process.env.NODE_ENV === "test") {
+    trackFunctionCall("node.email.send", [args]);
+    return;
+  }
   const validSMTPSettings = validateSMTPSettings(settings?.config?.email?.smtp);
   if (!validSMTPSettings) {
     console.warn(chalk.redBright("Cannot send email, invalid SMTP settings."));

package/dist/email/templates/reset-password.js

@@ -1,6 +1,5 @@
 import ui from "@joystick.js/ui";
 const ResetPassword = ui.component({
-  id: process.env.NODE_ENV === "test" ? "testComponent1234" : null,
   render: ({ props }) => {
     return `
       <p>A password reset was requested for this email address (${props.emailAddress}). If you requested this reset, click the link below to reset your password:</p>

package/dist/fixture/index.js

@@ -0,0 +1,40 @@
+class Fixture {
+  constructor(options = {}) {
+    this.options = options;
+    this.quantity = options?.quantity;
+    this.run = this.run.bind(this);
+    return this.run;
+  }
+  async run(input = {}) {
+    this.input = input;
+    const skip = typeof this?.options?.skip === "function" ? await this.options.skip(this, input) : false;
+    let dataToCreate = [];
+    if (!skip) {
+      dataToCreate = await this.generateDataToCreate(input);
+      if (typeof this?.options?.onCreate === "function") {
+        await this.options.onCreate(this, dataToCreate, (onAfterCreateEachInput = {}) => {
+          return this?.options?.onAfterCreateEach(this, onAfterCreateEachInput, input);
+        });
+      }
+    }
+    if (typeof this?.options?.onAfterCreateAll === "function") {
+      this.options.onAfterCreateAll(this, dataToCreate, input);
+    }
+  }
+  async generateDataToCreate(input = {}) {
+    const data = [];
+    for (let i = 0; i < this?.quantity; i += 1) {
+      if (typeof this?.options?.template === "function") {
+        const dataToCreate = await this.options?.template(this, i, input);
+        data.push(dataToCreate);
+      }
+    }
+    return data;
+  }
+}
+var fixture_default = (options = {}) => {
+  return new Fixture(options);
+};
+export {
+  fixture_default as default
+};

package/dist/index.js

@@ -4,22 +4,29 @@ import { dirname } from "path";
 import sanitizeHTML from "sanitize-html";
 import _accounts from "./app/accounts";
 import _action from "./action/index.js";
+import _fixture from "./fixture/index.js";
+import _test from "./test/index.js";
 import _websockets from "./websockets";
 import api from "./api/index.js";
 import app from "./app/index.js";
 import generateId from "./lib/generateId.js";
+import _generate_sql_from_object from "./app/databases/generate_sql_from_object";
 import getOrigin from "./api/getOrigin";
 import loadSettings from "./settings/load";
 import pushLogs from "./push/logs/index.js";
 import nodeUrlPolyfills from "./lib/nodeUrlPolyfills.js";
 import sendEmail from "./email/send";
+const { readFile } = fs.promises;
 if (process.env.NODE_ENV !== "development" && process.env.IS_PUSH_DEPLOYED) {
   pushLogs();
 }
+const generate_sql_from_object = _generate_sql_from_object;
 const accounts = _accounts;
 const action = _action;
+const fixture = _fixture;
 const get = api.get;
 const set = api.set;
+const test = _test;
 const email = {
   send: sendEmail
 };
@@ -36,6 +43,11 @@ const __dirname = nodeUrlPolyfills.__dirname;
 const id = generateId;
 const origin = getOrigin();
 const settings = loadSettings();
+const push = {
+  continent: fs.existsSync("/root/push/continent.txt") ? (await readFile("/root/push/continent.txt", "utf-8"))?.replace("\n", "") : null,
+  instance_token: fs.existsSync("/root/push/instance_token.txt") ? (await readFile("/root/push/instance_token.txt", "utf-8"))?.replace("\n", "") : null,
+  current_version: fs.existsSync("/root/push/versions/current") ? (await readFile("/root/push/versions/current", "utf-8"))?.replace("\n", "") : null
+};
 global.joystick = {
   id: generateId,
   emitters: {},
@@ -51,9 +63,12 @@ var src_default = {
   action,
   app,
   email,
+  fixture,
+  generate_sql_from_object,
   get,
   id,
   origin,
+  push,
   sanitize,
   set,
   settings,
@@ -67,10 +82,14 @@ export {
   action,
   src_default as default,
   email,
+  fixture,
+  generate_sql_from_object,
   get,
   id,
   origin,
+  push,
   sanitize,
   set,
+  test,
   websockets
 };

package/dist/lib/escapeKeyValuePair.js

@@ -0,0 +1,13 @@
+import escapeHTML from "./escapeHTML.js";
+var escapeKeyValuePair_default = (target = {}) => {
+  const parameters = Object.entries(target || {});
+  for (let i = 0; i < parameters?.length; i += 1) {
+    const [key, value] = parameters[i];
+    delete target[key];
+    target[escapeHTML(key)] = escapeHTML(value);
+  }
+  return target;
+};
+export {
+  escapeKeyValuePair_default as default
+};

package/dist/lib/formatAPIError.js

@@ -1,4 +1,3 @@
-import getErrorObject from "./getErrorObject";
 var formatAPIError_default = (exception = {}, location = "", code = 0) => {
   return {
     code,

package/dist/lib/getBuildPath.js

@@ -1,6 +1,6 @@
 import fs from "fs";
 var getBuildPath_default = () => {
-  if (process.env.NODE_ENV === "development" || fs.existsSync(".joystick/build")) {
+  if (["development", "test"].includes(process.env.NODE_ENV) || fs.existsSync(".joystick/build")) {
     return ".joystick/build/";
   }
   return "";

package/dist/lib/getSSLCertificates.js

@@ -1,12 +1,12 @@
 import fs from "fs";
 var getSSLCertificates_default = (ssl = null) => {
-  const pushCertificatePath = "/lib/push/certs/cert.pem";
-  const pushKeyPath = "/lib/push/certs/key.pem";
+  const pushCertificatePath = "/root/push/certs/cert.pem";
+  const pushKeyPath = "/root/push/certs/key.pem";
   const certPath = process.env.IS_PUSH_DEPLOYED ? pushCertificatePath : ssl?.cert || null;
   const keyPath = process.env.IS_PUSH_DEPLOYED ? pushKeyPath : ssl?.key || null;
   const certExists = fs.existsSync(certPath);
   const keyExists = fs.existsSync(keyPath);
-  if (process.env.NODE_ENV === "development" || !certExists || !keyExists) {
+  if (["development", "test"].includes(process.env.NODE_ENV) || !certExists || !keyExists) {
     return null;
   }
   return {

package/dist/lib/importFile.js

@@ -0,0 +1,7 @@
+var importFile_default = async (buildPath = "") => {
+  const file = await import(buildPath);
+  return file?.default;
+};
+export {
+  importFile_default as default
+};

package/dist/lib/isValidJSONString.js

@@ -1,10 +1,10 @@
 var isValidJSONString_default = (JSONString = "") => {
   try {
     JSON.parse(JSONString);
+    return true;
   } catch (error) {
     return false;
   }
-  return true;
 };
 export {
   isValidJSONString_default as default

package/dist/lib/log.js

@@ -1,9 +1,6 @@
 import chalk from "chalk";
 import rainbowRoad from "./rainbowRoad.js";
 var log_default = (message = "", options = {}) => {
-  if (process.env.NODE_ENV === "test") {
-    return;
-  }
   const colors = {
     info: "blue",
     success: "green",

package/dist/lib/objectToSQLKeysString.js

@@ -1,7 +1,7 @@
 import { isObject } from "../validation/lib/typeValidators";
 import camelPascalToSnake from "./camelPascalToSnake";
 const objectToSQLKeys = (objectToConvert = {}, target = []) => {
-  const keyValuePairs = Object.entries(objectToConvert);
+  const keyValuePairs = Object.entries(objectToConvert || {});
   keyValuePairs.forEach(([key, value]) => {
     if (isObject(value)) {
       target.push(camelPascalToSnake(key));

package/dist/lib/objectToSQLValuesString.js

@@ -1,6 +1,6 @@
 import { isObject } from "../validation/lib/typeValidators";
 const objectToSQLValues = (objectToConvert = {}, target = []) => {
-  const keyValuePairs = Object.entries(objectToConvert);
+  const keyValuePairs = Object.entries(objectToConvert || {});
   keyValuePairs.forEach(([_key, value]) => {
     if (isObject(value)) {
       objectToSQLValues(value, target);

package/dist/lib/serializeQueryParameters.js

@@ -1,5 +1,5 @@
 var serializeQueryParameters_default = (queryParameters = {}) => {
-  return Object.entries(queryParameters).map(([key, value]) => {
+  return Object.entries(queryParameters || {}).map(([key, value]) => {
     return `${key}=${value}`;
   })?.join("&");
 };

package/dist/lib/timestamps.js

@@ -0,0 +1,47 @@
+var timestamps_default = {
+  get_current_time: (options2 = {}) => {
+    const timestamp = new Date().toISOString();
+    return options2?.mongodb_ttl ? new Date(timestamp) : timestamp;
+  },
+  get_future_time: (unit = "", quantity = 0, options2 = {}) => {
+    const date = new Date();
+    switch (unit) {
+      case "seconds":
+        date.setSeconds(date.getSeconds() + quantity);
+        return options2?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      case "minutes":
+        date.setMinutes(date.getMinutes() + quantity);
+        return options2?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      case "hours":
+        date.setHours(date.getHours() + quantity);
+        return options2?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      case "days":
+        date.setHours(date.getHours() + quantity * 24);
+        return options2?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      default:
+        return options2?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+    }
+  },
+  get_past_time: (unit = "", quantity = 0) => {
+    const date = new Date();
+    switch (unit) {
+      case "seconds":
+        date.setSeconds(date.getSeconds() - quantity);
+        return options?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      case "minutes":
+        date.setMinutes(date.getMinutes() - quantity);
+        return options?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      case "hours":
+        date.setHours(date.getHours() - quantity);
+        return options?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      case "days":
+        date.setHours(date.getHours() - quantity * 24);
+        return options?.mongodb_ttl ? new Date(date.toISOString()) : date.toISOString();
+      default:
+        return options?.mongodb_ttl ? new Date(new Date().toISOString()) : new Date().toISOString();
+    }
+  }
+};
+export {
+  timestamps_default as default
+};

package/dist/lib/wait.js

@@ -0,0 +1,8 @@
+var wait_default = (seconds = 0) => {
+  return new Promise((resolve) => {
+    setTimeout(() => resolve(), seconds * 1e3);
+  });
+};
+export {
+  wait_default as default
+};

package/dist/push/logs/index.js

@@ -1,5 +1,7 @@
-import dayjs from "dayjs";
-import TuskDB from "@tuskdb/node";
+import { MongoClient } from "mongodb";
+import timestamps from "../../lib/timestamps";
+const KILOBYTE = 1e3;
+const MEGABYTE = KILOBYTE * 1e3;
 const captureLog = (callback = null) => {
   process.stdout.write = (data) => {
     if (callback) {
@@ -13,35 +15,51 @@ const captureLog = (callback = null) => {
   };
   process.on("uncaughtException", (error) => {
     if (callback) {
-      callback("uncaughtException", error);
+      callback("uncaughtException", error?.message || "Uncaught Exception");
     }
   });
-};
-const writeLogsToDisk = () => {
-  const db = new TuskDB({
-    file: {
-      development: "logs.json",
-      production: "/root/logs.json"
-    }[process.env.NODE_ENV || "development"],
-    collections: {
-      logs: []
+  process.on("unhandledRejection", (error) => {
+    if (callback) {
+      callback("unhandledRejection", error?.message || "Unhandled Rejection");
     }
   });
-  captureLog((source = "", data = "") => {
+};
+const connectMongoDB = async () => {
+  const client = new MongoClient("mongodb://localhost:27017");
+  const db = client.db("push");
+  try {
+    await db.createCollection("logs", { capped: true, size: MEGABYTE * 50, max: 1e3 });
+    await db.createCollection("metrics", { capped: true, size: MEGABYTE * 50, max: 1e3 });
+  } catch {
+  }
+  await client.connect();
+  return {
+    client,
+    db
+  };
+};
+const writeLogsToDisk = () => {
+  captureLog(async (source = "", data = "") => {
+    const mongodb = await connectMongoDB();
     switch (source) {
       case "stdout":
-        return db.collection("logs").insertOne({
+        await mongodb.db.collection("logs").insertOne({
           error: false,
-          timestamp: dayjs().format(),
+          timestamp: timestamps.get_current_time(),
+          process_id: process.pid,
           data
         });
+        return mongodb.client.close();
       case "stderr":
       case "uncaughtException":
-        return db.collection("logs").insertOne({
+      case "unhandledRejection":
+        await mongodb.db.collection("logs").insertOne({
           error: true,
-          timestamp: dayjs().format(),
+          timestamp: timestamps.get_current_time(),
+          process_id: process.pid,
           data
         });
+        return mongodb.client.close();
       default:
         return;
     }

package/dist/settings/load.js

@@ -1,11 +1,9 @@
 import isValidJSONString from "../lib/isValidJSONString";
 const defaultSettings = {
   config: {},
-  keys: {
-    global: {},
-    public: {},
-    private: {}
-  }
+  global: {},
+  public: {},
+  private: {}
 };
 var load_default = () => {
   try {

package/dist/ssr/compileCSS.js

@@ -30,7 +30,7 @@ var compileCSS_default = (css = "", componentInstance = {}) => {
         `;
       }
       if (hasMinRules && hasMinWidthRules) {
-        const minWidthRules = Object.entries(css?.min?.width);
+        const minWidthRules = Object.entries(css?.min?.width || {});
         for (let i = 0; i < minWidthRules.length; i += 1) {
           const [minWidth, minWidthRule] = minWidthRules[i];
           compiledCSS += `
@@ -41,7 +41,7 @@ var compileCSS_default = (css = "", componentInstance = {}) => {
         }
       }
       if (hasMinRules && hasMinHeightRules) {
-        const minHeightRules = Object.entries(css?.min?.height);
+        const minHeightRules = Object.entries(css?.min?.height || {});
         for (let i = 0; i < minHeightRules.length; i += 1) {
           const [minHeight, minHeightRule] = minHeightRules[i];
           compiledCSS += `
@@ -52,7 +52,7 @@ var compileCSS_default = (css = "", componentInstance = {}) => {
         }
       }
       if (hasMaxRules && hasMaxWidthRules) {
-        const maxWidthRules = Object.entries(css?.max?.width);
+        const maxWidthRules = Object.entries(css?.max?.width || {});
         for (let i = 0; i < maxWidthRules.length; i += 1) {
           const [maxWidth, maxWidthRule] = maxWidthRules[i];
           compiledCSS += `
@@ -63,7 +63,7 @@ var compileCSS_default = (css = "", componentInstance = {}) => {
         }
       }
       if (hasMaxRules && hasMaxHeightRules) {
-        const maxHeightRules = Object.entries(css?.max?.height);
+        const maxHeightRules = Object.entries(css?.max?.height || {});
         for (let i = 0; i < maxHeightRules.length; i += 1) {
           const [maxHeight, maxHeightRule] = maxHeightRules[i];
           compiledCSS += `

package/dist/ssr/findComponentInTree.js

@@ -4,7 +4,7 @@ const isObject = (value) => {
 const findComponentInTree = (tree = {}, componentId = "", callback = {}) => {
   const isTree = tree && tree.id;
   if (isObject(tree) && isTree) {
-    const entries = Object.entries(tree);
+    const entries = Object.entries(tree || {});
     for (let i = 0; i < entries.length; i += 1) {
       const [treeKey, treeValue] = entries[i];
       if (treeKey === "id" && treeValue === componentId) {

package/dist/ssr/getAPIForDataFunctions.js

@@ -0,0 +1,35 @@
+import get from "../api/get";
+import set from "../api/set";
+var getAPIForDataFunctions_default = (req = {}, api = {}) => {
+  try {
+    return {
+      get: (getterName = "", getterOptions = {}) => {
+        return get({
+          getterName,
+          getterOptions: api?.getters[getterName] || {},
+          skip: getterOptions?.skip,
+          input: getterOptions?.input,
+          output: getterOptions?.output,
+          context: req?.context,
+          APIOptions: api?.options
+        });
+      },
+      set: (setterName = "", setterOptions = {}) => {
+        return set({
+          setterName,
+          setterOptions: api?.setters[setterName] || {},
+          skip: setterOptions?.skip,
+          input: setterOptions?.input,
+          output: setterOptions?.output,
+          context: req?.context,
+          APIOptions: api?.options
+        });
+      }
+    };
+  } catch (exception) {
+    throw new Error(`[ssr.getAPIForDataFunctions] ${exception.message}`);
+  }
+};
+export {
+  getAPIForDataFunctions_default as default
+};

package/dist/ssr/getDataFromComponent.js

@@ -0,0 +1,15 @@
+var getDataFromComponent_default = async (componentInstance = {}, api = {}, browserSafeUser = {}, browserSafeRequest = {}) => {
+  try {
+    componentInstance.user = browserSafeUser;
+    const data = await componentInstance.handleFetchData(api, browserSafeRequest, {}, componentInstance);
+    return {
+      componentId: componentInstance?.id,
+      data
+    };
+  } catch (exception) {
+    throw new Error(`[ssr.getDataFromComponent] ${exception.message}`);
+  }
+};
+export {
+  getDataFromComponent_default as default
+};