@things-factory/shell 8.0.0-beta.1 → 8.0.0-beta.2

package/server/typeorm/encrypt-transform.ts

@@ -1,70 +0,0 @@
-import { ValueTransformer } from 'typeorm'
-import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from 'crypto'
-
-import { dataEncryptionKey } from './get-data-encryption-key'
-
-const ALGORITHM = 'aes-256-cbc'
-const KEY_LENGTH = 32
-const SALT_LENGTH = 16
-const IV_LENGTH = 16
-
-/**
- * ValueTransformer object for encrypting and decrypting database entity field values.
- * Used in TypeORM entities to encrypt field values before storing them in the database
- * and decrypt values when retrieving them from the database.
- */
-export const encryptTransformer: ValueTransformer = {
-  /**
-   * Encrypts the entity field value before storing it in the database.
-   * @param {string} entityValue - Unencrypted entity field value
-   * @returns {string} - Encrypted string
-   */
-  to: (entityValue: string) => encrypt(entityValue), // DB에 저장하기 전에 암호화
-
-  /**
-   * Decrypts the encrypted database value when retrieving it from the database.
-   * @param {string} databaseValue - Encrypted database field value
-   * @returns {string} - Decrypted string
-   */
-  from: (databaseValue: string) => decrypt(databaseValue) // DB에서 값을 가져올 때 복호화
-}
-
-/**
- * Encrypts the given text using the AES-256-CBC algorithm.
- * @param {string} text - Text to encrypt
- * @returns {string} - Encrypted string
- */
-function encrypt(text: string): string {
-  if (!text) {
-    return null
-  }
-
-  const iv = randomBytes(IV_LENGTH)
-  const cipher = createCipheriv(ALGORITHM, dataEncryptionKey, iv)
-  const encrypted = Buffer.concat([cipher.update(text, 'utf8'), cipher.final()])
-
-  return `${iv.toString('hex')}:${encrypted.toString('hex')}`
-}
-
-/**
- * Decrypts the given encrypted text.
- * @param {string} text - Encrypted text to decrypt
- * @returns {string} - Decrypted string
- */
-function decrypt(text: string): string {
-  if (!text) {
-    return null
-  }
-
-  try {
-    const parts = text.split(':')
-    const iv = Buffer.from(parts.shift(), 'hex')
-    const encryptedText = Buffer.from(parts.join(':'), 'hex')
-    const decipher = createDecipheriv(ALGORITHM, dataEncryptionKey, iv)
-
-    return Buffer.concat([decipher.update(encryptedText), decipher.final()]).toString('utf8')
-  } catch (err) {
-    console.error(`decryption for encrypted field failed in encryptTransformer`)
-    return null
-  }
-}

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

@@ -1,13 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,226 +0,0 @@
-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 '/'
-  }
-}