@things-factory/shell 8.0.2 → 8.0.13

package/server/service/domain/domain.ts

@@ -7,17 +7,11 @@ import {
   Entity,
   Index,
   UpdateDateColumn,
-  DeleteDateColumn
+  DeleteDateColumn,
+  PrimaryGeneratedColumn
 } from 'typeorm'
 import { ObjectType, Directive, Field, ID } from 'type-graphql'
-import { config } from '@things-factory/env'
-import { ScalarObject } from '../common-types'
-
-const numericTypes = ['int', 'int2', 'int4', 'int8', 'integer', 'tinyint', 'smallint', 'mediumint', 'bigint']
-const generatedStrategy = ['uuid', 'rowid', 'increment', 'identity']
-const domainPrimaryOption = config.get('domainPrimaryOption')
-const domainPrimaryType = domainPrimaryOption?.type
-const domainPrimaryStrategy = domainPrimaryOption?.strategy
+import { ScalarObject } from '../common-types/scalar-object.js'
 
 export type IPList = {
   whitelist?: string[]
@@ -36,37 +30,8 @@ export type IPList = {
 })
 @ObjectType()
 export class Domain {
+  @PrimaryGeneratedColumn('uuid')
   @Field(type => ID)
-  @Column(
-    domainPrimaryOption
-      ? {
-          type: domainPrimaryType,
-          primary: true,
-          transformer: {
-            //from(value: DatabaseType): EntityType
-            from: value => {
-              return value
-            },
-            //to(value: EntityType): DatabaseType
-            to: value => {
-              if (!value) {
-                value = 0
-              }
-              if (numericTypes.indexOf(domainPrimaryType) >= 0) {
-                return parseInt(value)
-              } else {
-                return value
-              }
-            }
-          },
-          generated: generatedStrategy.indexOf(domainPrimaryStrategy) >= 0 ? domainPrimaryStrategy : false
-        }
-      : {
-          type: 'uuid',
-          primary: true,
-          generated: 'uuid'
-        }
-  )
   readonly id: string
 
   @Field()

package/server/utils/get-domain.ts

@@ -6,10 +6,16 @@ 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)
+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.
@@ -51,18 +57,6 @@ export function getUrlFromContext(context, path = '') {
   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.
  *
@@ -72,9 +66,9 @@ function getSubdomainsFromHost(context: any) {
 function getSubdomainFromPath(context: any) {
   var { path } = context
 
-  var domain = getPathInfo(path || '')?.domain
-  if (domain) {
-    return domain
+  var subdomain = getPathInfo(path || '', domainTypes)?.subdomain
+  if (subdomain) {
+    return subdomain
   }
 
   var {
@@ -83,20 +77,32 @@ function getSubdomainFromPath(context: any) {
 
   if (referer) {
     var { pathname } = new URL(referer)
-    return getPathInfo(pathname || '')?.domain
+    return getPathInfo(pathname || '', domainTypes)?.subdomain
   }
 }
 
 /**
- * Extracts a subdomain based on virtual host.
+ * Extracts the subdomain type from the given context's path or referer header.
  *
- * @param context {Object} An object containing the current request context information.
- * @returns {string} The extracted subdomain.
+ * @param context - The context object containing path and header information.
+ * @returns The subdomain type if found, otherwise undefined.
  */
-function getSubdomainFromVhost(context: any) {
-  const subdomain = (context.subdomains || getSubdomainsFromHost(context)).slice(-1)[0]
+function getSubdomainTypeFromPath(context: any) {
+  var { path } = context
+
+  var prefix = getPathInfo(path || '', domainTypes)?.prefix
+  if (prefix) {
+    return prefix
+  }
+
+  var {
+    header: { referer }
+  } = context
 
-  return subdomain
+  if (referer) {
+    var { pathname } = new URL(referer)
+    return getPathInfo(pathname || '', domainTypes)?.prefix
+  }
 }
 
 /**
@@ -106,7 +112,11 @@ function getSubdomainFromVhost(context: any) {
  * @returns {string} The extracted subdomain.
  */
 function getSubdomainFromURL(context) {
-  return fixed || (useVirtualHostBasedDomain ? getSubdomainFromVhost(context) : getSubdomainFromPath(context))
+  return fixed || getSubdomainFromPath(context)
+}
+
+function getSubdomainTypeFromURL(context) {
+  return fixed ? '' : getSubdomainTypeFromPath(context)
 }
 
 /**
@@ -119,21 +129,21 @@ 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: { 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('.')
+    return await getRepository(Domain).findOne({
+      where:
+        fixed || extType == 'domain' || !extType
+          ? {
+              subdomain
+            }
+          : {
+              subdomain,
+              extType
+            },
+      cache: true
+    })
   }
 }
 
@@ -143,42 +153,37 @@ export function getCookieDomainFromHostname(hostname) {
  * @param subdomain {string} The subdomain.
  * @returns {string} The generated context path.
  */
-export function getContextPath(subdomain) {
-  return fixed || useVirtualHostBasedDomain ? '' : '/domain/' + subdomain
+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 {string} The subdomain.
+ * @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, subdomain, redirectTo = '/') {
-  if (fixed) {
+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
 
-  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\/([^\/]+)/)
+  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}`
-    }
+  if (match) {
+    parsed.pathname = pathname.replace(match[0], contextPath)
+  } else {
+    parsed.pathname = `${contextPath}${pathname}`
   }
 
   return parsed.toString()
@@ -197,16 +202,21 @@ export function findSubdomainFromPath(context, path) {
   }
 
   var parsed = getUrlFromContext(context, path)
-  var { hostname, pathname } = parsed
-
-  if (useVirtualHostBasedDomain) {
-    return hostname.split('.').reverse()[subdomainOffset]
-  }
+  var { pathname } = parsed
 
-  const match = pathname.match(/^\/domain\/([^\/]+)/)
+  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.
  *
@@ -214,13 +224,5 @@ export function findSubdomainFromPath(context, path) {
  * @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 '/'
-  }
+  return '/'
 }

package/server/utils/get-query-builder-from-list-params.ts

@@ -1,7 +1,7 @@
 import { Brackets, EntityMetadata, Repository, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm'
-import { RelationMetadata } from 'typeorm/metadata/RelationMetadata'
-import { Filter, Sorting, Pagination, ListParam, InheritedValueType } from '../service/common-types/list-param'
-import { Domain } from '../service/domain/domain'
+import { RelationMetadata } from 'typeorm/metadata/RelationMetadata.js'
+import { Filter, Sorting, Pagination, ListParam, InheritedValueType } from '../service/common-types/list-param.js'
+import { Domain } from '../service/domain/domain.js'
 
 /**
  * Creates a TypeORM SelectQueryBuilder based on the provided parameters.