@things-factory/shell 8.0.37 → 9.0.0-9.0.0-beta.59.0

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 entityValue === null || entityValue === undefined ? null : 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 databaseValue === null ? null : 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,228 +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 protocol: string = config.get('protocol')
-const fixed = config.get('subdomain')
-const domainTypes = config.get('domainTypes') || ['domain']
-
-/* 하위 호환성을 위해서, domain prefix가 없는 경우, domain을 추가해준다. */
-if (domainTypes.indexOf('domain') < 0) {
-  domainTypes.push('domain')
-}
-
-const routePrefixForDomainType = `:domainType(${domainTypes.join('|')})`
-
-/**
- * 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 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 subdomain = getPathInfo(path || '', domainTypes)?.subdomain
-  if (subdomain) {
-    return subdomain
-  }
-
-  var {
-    header: { referer }
-  } = context
-
-  if (referer) {
-    var { pathname } = new URL(referer)
-    return getPathInfo(pathname || '', domainTypes)?.subdomain
-  }
-}
-
-/**
- * Extracts the subdomain type from the given context's path or referer header.
- *
- * @param context - The context object containing path and header information.
- * @returns The subdomain type if found, otherwise undefined.
- */
-function getSubdomainTypeFromPath(context: any) {
-  var { path } = context
-
-  var prefix = getPathInfo(path || '', domainTypes)?.prefix
-  if (prefix) {
-    return prefix
-  }
-
-  var {
-    header: { referer }
-  } = context
-
-  if (referer) {
-    var { pathname } = new URL(referer)
-    return getPathInfo(pathname || '', domainTypes)?.prefix
-  }
-}
-
-/**
- * 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 || getSubdomainFromPath(context)
-}
-
-function getSubdomainTypeFromURL(context) {
-  return fixed ? '' : getSubdomainTypeFromPath(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)
-  const extType = header['x-things-factory-type'] || getSubdomainTypeFromURL(context)
-
-  if (subdomain) {
-    return await getRepository(Domain).findOne({
-      where:
-        fixed || extType == 'domain' || !extType
-          ? {
-              subdomain
-            }
-          : {
-              subdomain,
-              extType
-            },
-      cache: true
-    })
-  }
-}
-
-/**
- * Generates a context path based on the subdomain.
- *
- * @param subdomain {string} The subdomain.
- * @returns {string} The generated context path.
- */
-export function getContextPath(domain: Domain) {
-  const type = domain?.extType || 'domain'
-  return fixed || !domain ? '' : `${type}/${domain?.subdomain}/`
-}
-
-/**
- * Generates a redirection path considering the subdomain.
- *
- * @param context {Object} An object containing the current request context information.
- * @param subdomain {Domain} The target domain.
- * @param redirectTo {string} The path to redirect to (optional).
- * @returns {string} The generated redirection path.
- */
-export function getRedirectSubdomainPath(context, domain: Partial<Domain>, redirectTo: string = '/') {
-  if (fixed || !domain) {
-    return redirectTo || '/'
-  }
-
-  const type = domain.extType || 'domain'
-  const subdomain = domain.subdomain || fixed
-
-  var parsed = getUrlFromContext(context, redirectTo)
-  var { hostname, pathname } = parsed
-
-  const contextPath = `/${type}/${subdomain}`
-  const match = pathname.match(new RegExp(`^/${type}/([^\/]+)`))
-
-  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 { pathname } = parsed
-
-  const match = pathname.match(new RegExp(`^/${getSubdomainTypeFromURL(context)}/([^\/]+)`))
-  return match && match[1]
-}
-
-/**
- * Retrieves the route prefix for a specific domain type.
- *
- * @returns {string} The route prefix associated with the domain type.
- */
-export function getRoutePrefixForDomainType() {
-  return routePrefixForDomainType
-}
-
-/**
- * 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) {
-  return '/'
-}