@things-factory/shell 8.0.0-beta.9 → 8.0.0

package/server/typeorm/get-data-encryption-key.ts

@@ -0,0 +1,13 @@
+import { config } from '@things-factory/env'
+
+var _DATA_ENCRYPTION_KEY = config.get('dataEncryptionKey')
+
+if (!_DATA_ENCRYPTION_KEY) {
+  if (process.env.NODE_ENV == 'production') {
+    throw new TypeError('dataEncryptionKey not configured.')
+  } else {
+    _DATA_ENCRYPTION_KEY = 'V6g5oHJZb7KcYzIyL6cM95XvIDouon5b'
+  }
+}
+
+export const dataEncryptionKey = _DATA_ENCRYPTION_KEY

package/server/typeorm/json5-transform.ts

@@ -0,0 +1,26 @@
+import { ValueTransformer } from 'typeorm'
+import json5 from 'json5'
+
+export const json5Transformer: ValueTransformer = {
+  /**
+   * Converts the entity's value to a JSON5 string before storing it in the database.
+   * @param {any} entityValue - The unencrypted entity field value.
+   * @returns {string} - The stringified JSON5 representation of the entityValue.
+   */
+  to(entityValue: any) {
+    return json5.stringify(entityValue)
+  },
+
+  /**
+   * Converts a JSON5 string from the database back into its original type when retrieving it.
+   * @param {string} databaseValue - The JSON5 string stored in the database.
+   * @returns {any} - The original type of the entityValue, parsed from the JSON5 string.
+   */
+  from(databaseValue: string) {
+    try {
+      return json5.parse(databaseValue)
+    } finally {
+      return databaseValue
+    }
+  }
+}

package/server/typeorm/round-transform.ts

@@ -0,0 +1,20 @@
+import { ValueTransformer } from 'typeorm'
+
+/**
+ * ValueTransformer object for rounding floating point values.
+ */
+export const roundTransformer: ValueTransformer = {
+  /**
+   * Rounds the entity field value before storing it in the database.
+   * @param {number | null} value - Floating point value to round or null
+   * @returns {number | null} - Rounded number or null
+   */
+  to: (value: number | null) => (value !== null && !isNaN(value) ? Math.round(value * 10000) / 10000 : undefined),
+
+  /**
+   * Returns the entity field value as it is without any transformation when reading from the database.
+   * @param {number} value - Number value read from the database
+   * @returns {number} - The number value as is
+   */
+  from: (value: number) => value
+}

package/server/utils/condition-builder.ts

@@ -0,0 +1,145 @@
+import _ from 'lodash'
+
+/**
+ * Generates and returns a condition clause based on the provided parameters.
+ *
+ * @param alias {string} Alias or table name of the entity.
+ * @param fieldName {string} Field or column name.
+ * @param operator {string} Comparison operator.
+ * @param value {any} Value or an array of values to compare.
+ * @param relation {boolean | string} Indicates if it's a related field or the name of the relation (optional).
+ * @param seq {number} Integer representing the order of condition generation (internal use).
+ * @returns {Object} An object containing the generated condition clause and parameters.
+ */
+export const buildCondition = function (alias: string, fieldName: string, operator: string, value: any, relation: boolean | string, seq: number) {
+  seq++
+
+  fieldName = _.snakeCase(fieldName)
+  const values = value instanceof Array ? value : [value]
+
+  switch (operator) {
+    case 'eq':
+      return {
+        clause: `${alias}.${fieldName} = :args${seq}`,
+        parameters: { [`args${seq}`]: value }
+      }
+
+    case 'like':
+      return {
+        clause: `${alias}.${fieldName} LIKE :args${seq}`,
+        parameters: { [`args${seq}`]: `${value}` }
+      }
+
+    case 'search':
+    case 'i_like':
+      return {
+        clause: `LOWER(${alias}.${fieldName}) LIKE :args${seq}`,
+        parameters: { [`args${seq}`]: `${String(value).toLowerCase()}` }
+      }
+
+    case 'nlike':
+      return {
+        clause: `${alias}.${fieldName} NOT LIKE :args${seq}`,
+        value: { [`args${seq}`]: `${value}` }
+      }
+
+    case 'i_nlike':
+      return {
+        clause: `LOWER(${alias}.${fieldName}) NOT LIKE :args${seq}`,
+        value: { [`args${seq}`]: `${String(value).toLowerCase()}` }
+      }
+
+    case 'lt':
+      return {
+        clause: `${alias}.${fieldName} < :args${seq}`,
+        parameters: { [`args${seq}`]: value }
+      }
+
+    case 'gt':
+      return {
+        clause: `${alias}.${fieldName} > :args${seq}`,
+        parameters: { [`args${seq}`]: value }
+      }
+
+    case 'lte':
+      return {
+        clause: `${alias}.${fieldName} <= :args${seq}`,
+        parameters: { [`args${seq}`]: value }
+      }
+
+    case 'gte':
+      return {
+        clause: `${alias}.${fieldName} >= :args${seq}`,
+        parameters: { [`args${seq}`]: value }
+      }
+
+    case 'noteq':
+      return {
+        clause: `${alias}.${fieldName} != :args${seq}`,
+        parameters: { [`args${seq}`]: value }
+      }
+
+    case 'in':
+      return {
+        clause: relation ? `${fieldName}.id IN (:...args${seq})` : `${alias}.${fieldName} IN (:...args${seq})`,
+        parameters: { [`args${seq}`]: values }
+      }
+
+    case 'notin':
+      return {
+        clause: relation ? `${fieldName}.id NOT IN (:...args${seq})` : `${alias}.${fieldName} NOT IN (:...args${seq})`,
+        parameters: { [`args${seq}`]: values }
+      }
+
+    case 'notin_with_null':
+      return {
+        clause: relation
+          ? `(${fieldName}.id IS NULL OR ${fieldName}.id  NOT IN (:...args${seq})`
+          : `${alias}.${fieldName} IS NULL OR ${alias}.${fieldName} NOT IN (:...args${seq}))`,
+        parameters: { [`args${seq}`]: values }
+      }
+
+    case 'is_null':
+      return {
+        clause: `${alias}.${fieldName} IS NULL`
+      }
+    case 'is_not_null':
+      return {
+        clause: `${alias}.${fieldName} IS NOT NULL`
+      }
+    case 'is_false':
+      return {
+        clause: `${alias}.${fieldName} IS FALSE`
+      }
+    case 'is_true':
+      return {
+        clause: `${alias}.${fieldName} IS TRUE`
+      }
+    case 'is_not_false':
+      return {
+        clause: `${alias}.${fieldName} IS NOT FALSE`
+      }
+    case 'is_not_true':
+      return {
+        clause: `${alias}.${fieldName} IS NOT TRUE`
+      }
+    case 'is_present':
+      return {
+        clause: `${alias}.${fieldName} IS PRESENT`
+      }
+    case 'is_blank':
+      return {
+        clause: `${alias}.${fieldName} IS BLANK`
+      }
+    case 'is_empty_num_id':
+      return {
+        clause: `${alias}.${fieldName} IS EMPTY NUMERIC ID`
+      }
+
+    case 'between':
+      return {
+        clause: `${alias}.${fieldName} BETWEEN  :args${seq}_1 AND :args${seq}_2`,
+        parameters: { [`args${seq}_1`]: values[0], [`args${seq}_2`]: values[1] }
+      }
+  }
+}

package/server/utils/get-domain.ts

@@ -0,0 +1,226 @@
+import { URL } from 'url'
+
+import { config } from '@things-factory/env'
+import { getPathInfo } from '@things-factory/utils'
+
+import { getRepository } from '../initializers/database'
+import { Domain } from '../service/domain/domain'
+
+const useVirtualHostBasedDomain = !!config.get('useVirtualHostBasedDomain')
+const protocol: string = config.get('protocol')
+const fixed = config.get('subdomain')
+const subdomainOffset = config.getNumber('subdomainOffset', 2)
+
+/**
+ * Creates a URL based on the given context and path.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @param path {string} The path to be added to the created URL (optional).
+ * @returns {URL} The generated URL object.
+ */
+export function getUrlFromContext(context, path = '') {
+  const { method, href, host, header } = context
+  const { referer } = header || {}
+
+  var base = href
+
+  if (method !== 'GET' && referer) {
+    var { host: refererHost } = new URL(referer)
+    if (refererHost === host) {
+      base = referer
+    }
+  }
+
+  let url: URL = new URL(path, base)
+
+  const originalProtocol = context.headers['x-forwarded-proto']
+  const originalHost = context.headers['x-forwarded-host']
+  const originalPort = context.headers['x-forwarded-port']
+
+  if (protocol || originalProtocol) {
+    url.protocol = protocol || originalProtocol
+  }
+
+  if (originalHost) {
+    url.host = originalHost
+    if (originalPort) {
+      url.port = originalPort
+    }
+  }
+
+  return url
+}
+
+/**
+ * Extracts subdomains from the Host header.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string[]} An array of extracted subdomains.
+ */
+function getSubdomainsFromHost(context: any) {
+  const { request } = context
+  var subdomains = request.headers.host.split('.').reverse()
+  return subdomains.slice(subdomainOffset)
+}
+
+/**
+ * Extracts a subdomain from the path.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The extracted subdomain.
+ */
+function getSubdomainFromPath(context: any) {
+  var { path } = context
+
+  var domain = getPathInfo(path || '')?.domain
+  if (domain) {
+    return domain
+  }
+
+  var {
+    header: { referer }
+  } = context
+
+  if (referer) {
+    var { pathname } = new URL(referer)
+    return getPathInfo(pathname || '')?.domain
+  }
+}
+
+/**
+ * Extracts a subdomain based on virtual host.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The extracted subdomain.
+ */
+function getSubdomainFromVhost(context: any) {
+  const subdomain = (context.subdomains || getSubdomainsFromHost(context)).slice(-1)[0]
+
+  return subdomain
+}
+
+/**
+ * Extracts a subdomain from the URL context.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The extracted subdomain.
+ */
+function getSubdomainFromURL(context) {
+  return fixed || (useVirtualHostBasedDomain ? getSubdomainFromVhost(context) : getSubdomainFromPath(context))
+}
+
+/**
+ * Asynchronously searches for a domain object based on the URL context.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {Promise<Domain>} A promise that resolves to the domain object.
+ */
+export async function getDomainFromURL(context: any): Promise<Domain> {
+  const { header } = context
+
+  const subdomain = header['x-things-factory-domain'] || getSubdomainFromURL(context)
+
+  if (subdomain) {
+    return await getRepository(Domain).findOne({ where: { subdomain }, cache: true })
+  }
+}
+
+/**
+ * Extracts the cookie domain from the hostname.
+ *
+ * @param hostname {string} The hostname.
+ * @returns {string} The extracted cookie domain.
+ */
+export function getCookieDomainFromHostname(hostname) {
+  if (useVirtualHostBasedDomain) {
+    return hostname.split('.').slice(-subdomainOffset).join('.')
+  }
+}
+
+/**
+ * Generates a context path based on the subdomain.
+ *
+ * @param subdomain {string} The subdomain.
+ * @returns {string} The generated context path.
+ */
+export function getContextPath(subdomain) {
+  return fixed || useVirtualHostBasedDomain ? '' : '/domain/' + subdomain
+}
+
+/**
+ * Generates a redirection path considering the subdomain.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @param subdomain {string} The subdomain.
+ * @param redirectTo {string} The path to redirect to (optional).
+ * @returns {string} The generated redirection path.
+ */
+export function getRedirectSubdomainPath(context, subdomain, redirectTo = '/') {
+  if (fixed) {
+    return redirectTo || '/'
+  }
+
+  var parsed = getUrlFromContext(context, redirectTo)
+  var { hostname, pathname } = parsed
+
+  if (useVirtualHostBasedDomain) {
+    const splitHost = hostname.split('.').reverse()
+    splitHost[subdomainOffset] = subdomain
+    parsed.hostname = splitHost
+      .reverse()
+      .filter(a => a)
+      .join('.')
+  } else {
+    const contextPath = `/domain/${subdomain}`
+    const match = pathname.match(/^\/domain\/([^\/]+)/)
+
+    if (match) {
+      parsed.pathname = pathname.replace(match[0], contextPath)
+    } else {
+      parsed.pathname = `${contextPath}${pathname}`
+    }
+  }
+
+  return parsed.toString()
+}
+
+/**
+ * Finds a subdomain from the given path.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @param path {string} The path to search in.
+ * @returns {string} The found subdomain.
+ */
+export function findSubdomainFromPath(context, path) {
+  if (fixed) {
+    return fixed
+  }
+
+  var parsed = getUrlFromContext(context, path)
+  var { hostname, pathname } = parsed
+
+  if (useVirtualHostBasedDomain) {
+    return hostname.split('.').reverse()[subdomainOffset]
+  }
+
+  const match = pathname.match(/^\/domain\/([^\/]+)/)
+  return match && match[1]
+}
+
+/**
+ * Generates a site root path based on the current environment.
+ *
+ * @param context {Object} An object containing the current request context information.
+ * @returns {string} The generated site root path.
+ */
+export function getSiteRootPath(context) {
+  if (useVirtualHostBasedDomain) {
+    var { protocol, host } = context
+    protocol = protocol.replace(':', '')
+
+    let domainname = host.split('.').slice(-subdomainOffset).join('.')
+    return protocol + '://' + domainname + '/'
+  } else {
+    return '/'
+  }
+}