@things-factory/setting-base 8.0.0-beta.9 → 8.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/setting-base",
-  "version": "8.0.0-beta.9",
+  "version": "8.0.2",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,8 +27,8 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.9",
-    "@things-factory/code-base": "^8.0.0-beta.9"
+    "@things-factory/auth-base": "^8.0.2",
+    "@things-factory/code-base": "^8.0.2"
   },
-  "gitHead": "86b1dfa26292926a2d5447fdc23bfa5a9e983245"
+  "gitHead": "39d60f56e142561233ddf6d47b539c637971357c"
 }

package/server/index.ts

@@ -0,0 +1,2 @@
+export * from './service'
+export * from './migrations'

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})

package/server/service/index.ts

@@ -0,0 +1,25 @@
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as PartnerSettingEntities, resolvers as PartnerSettingResolvers } from './partner-setting'
+import { entities as SettingEntities, resolvers as SettingResolvers } from './setting'
+
+/* EXPORT ENTITY TYPES */
+export * from './partner-setting/partner-setting'
+export * from './setting/setting'
+
+/* EXPORT TYPES */
+export * from './partner-setting/partner-setting-type'
+export * from './setting/setting-type'
+
+export const entities = [
+  /* ENTITIES */
+  ...PartnerSettingEntities,
+  ...SettingEntities
+]
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+    ...PartnerSettingResolvers,
+    ...SettingResolvers
+  ]
+}

package/server/service/partner-setting/index.ts

@@ -0,0 +1,6 @@
+import { PartnerSetting } from './partner-setting'
+import { PartnerSettingQuery } from './partner-setting-query'
+import { PartnerSettingMutation } from './partner-setting-mutation'
+
+export const entities = [PartnerSetting]
+export const resolvers = [PartnerSettingQuery, PartnerSettingMutation]

package/server/service/partner-setting/partner-setting-mutation.ts

@@ -0,0 +1,98 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In, Repository } from 'typeorm'
+
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { Setting } from '../setting/setting'
+import { PartnerSetting } from './partner-setting'
+import { PartnerSettingPatch } from './partner-setting-type'
+
+@Resolver(PartnerSetting)
+export class PartnerSettingMutation {
+  @Directive('@transaction')
+  @Mutation(returns => [PartnerSetting], { description: "To modify multiple PartnerSettings' information" })
+  async updateMultiplePartnerSetting(
+    @Arg('patches', type => [PartnerSettingPatch]) patches: PartnerSettingPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<PartnerSetting[]> {
+    const { tx, domain, user } = context.state
+    const partnerSettingRepo: Repository<PartnerSetting> =
+      tx?.getRepository(PartnerSetting) || getRepository(PartnerSetting)
+    const domainRepo: Repository<Domain> = tx?.getRepository(Domain) || getRepository(Domain)
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+
+    const { createRecords, updateRecords } = patches.reduce(
+      (records, patch) => {
+        if (patch.cuFlag === '+') records.createRecords.push(patch)
+        if (patch.cuFlag.toUpperCase() === 'M') records.updateRecords.push(patch)
+
+        return records
+      },
+      { createRecords: [], updateRecords: [] }
+    )
+
+    let results: PartnerSetting[] = []
+
+    if (createRecords?.length) {
+      await Promise.all(
+        createRecords.map(async (record: PartnerSetting) => {
+          const partnerDomain: Domain = await domainRepo.findOneBy({ id: record.partnerDomain.id })
+          const setting: Setting = await settingRepo.findOneBy({ id: record.setting.id })
+
+          const result: PartnerSetting = await partnerSettingRepo.save({
+            domain,
+            creator: user,
+            updater: user,
+            ...record,
+            name: setting.name,
+            description: setting.description,
+            category: setting.category,
+            partnerDomain,
+            setting
+          })
+
+          results.push(result)
+        })
+      )
+    }
+
+    if (updateRecords?.length) {
+      await Promise.all(
+        updateRecords.map(async (record: PartnerSetting) => {
+          const partnerDomain: Domain = await domainRepo.findOneBy({ id: record.partnerDomain.id })
+          const setting: Setting = await settingRepo.findOneBy({ id: record.setting.id })
+
+          const partnerSetting: PartnerSetting = await partnerSettingRepo.findOneBy({ id: setting.id })
+          if (!record.id) throw new Error('Cannot update record without its ID')
+
+          const result = await partnerSettingRepo.save({
+            ...partnerSetting,
+            ...record,
+            name: setting.name,
+            description: setting.description,
+            category: setting.category,
+            updater: user,
+            partnerDomain,
+            setting
+          })
+
+          results.push(result)
+        })
+      )
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple partnerSettings' })
+  async deletePartnerSettings(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(PartnerSetting).delete({ id: In(ids), domain: { id: domain.id } })
+    return true
+  }
+}

package/server/service/partner-setting/partner-setting-query.ts

@@ -0,0 +1,123 @@
+import { Arg, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { SelectQueryBuilder } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import {
+  Domain,
+  Filter,
+  getRepository,
+  ObjectRef,
+  Pagination,
+  Sorting,
+  getQueryBuilderFromListParams
+} from '@things-factory/shell'
+
+import { Setting } from '../setting/setting'
+import { PartnerSetting } from './partner-setting'
+import { PartnerSettingList } from './partner-setting-type'
+
+@Resolver(PartnerSetting)
+export class PartnerSettingQuery {
+  @Query(returns => PartnerSetting, { description: 'To fetch a PartnerSetting' })
+  async partnerSetting(
+    @Arg('name') name: string,
+    @Arg('partnerDomainId') partnerDomainId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<PartnerSetting> {
+    const { domain } = context.state
+    const setting: Setting = await getRepository(Setting).findOne({ where: { domain: { id: domain.id }, name } })
+
+    const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOne({
+      where: { domain: { id: domain.id }, setting: { id: setting.id }, partnerDomain: { id: partnerDomainId } }
+    })
+
+    if (!partnerSetting) throw new Error(`${name} setting is not found`)
+
+    return partnerSetting || (setting as PartnerSetting)
+  }
+
+  @Query(returns => PartnerSettingList, { description: 'To fetch multiple PartnerSettings' })
+  async partnerSettings(
+    @Arg('filters', type => [Filter]) filters: Filter[],
+    @Arg('pagination', type => Pagination) pagination: Pagination,
+    @Arg('sortings', type => [Sorting]) sortings: Sorting[],
+    @Arg('partnerDomain', type => ObjectRef) partnerDomain: ObjectRef,
+    @Ctx() context: ResolverContext
+  ): Promise<PartnerSettingList> {
+    const { domain } = context.state
+    const qb: SelectQueryBuilder<PartnerSetting> = await getQueryBuilderFromListParams({
+      repository: getRepository(PartnerSetting),
+      alias: 'ps',
+      params: { filters, pagination, sortings },
+      domain,
+      searchables: ['name', 'description'],
+      filtersMap: {
+        name: {
+          relationColumn: 'setting',
+          columnName: 'name'
+        },
+        description: {
+          relationColumn: 'setting',
+          columnName: 'description'
+        }
+      }
+    })
+
+    qb.leftJoinAndSelect('ps.setting', 'Setting').andWhere('ps.partner_domain_id = :partnerDomainId', {
+      partnerDomainId: partnerDomain.id
+    })
+    const [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async partnerDomain(@Root() partnerSetting: PartnerSetting): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: partnerSetting.partnerDomainId })
+  }
+
+  @FieldResolver(type => Setting)
+  async setting(@Root() partnerSetting: PartnerSetting): Promise<Setting> {
+    return await getRepository(Setting).findOneBy({ id: partnerSetting.settingId })
+  }
+
+  @FieldResolver(type => String)
+  async name(@Root() partnerSetting: PartnerSetting): Promise<string> {
+    if (partnerSetting.setting?.name) {
+      return partnerSetting.setting.name
+    }
+
+    return (await getRepository(Setting).findOneBy({ id: partnerSetting.settingId }))?.name
+  }
+
+  async description(@Root() partnerSetting: PartnerSetting): Promise<string> {
+    if (partnerSetting.setting?.description) {
+      return partnerSetting.setting.description
+    }
+
+    return (await getRepository(Setting).findOneBy({ id: partnerSetting.settingId }))?.description
+  }
+
+  async category(@Root() partnerSetting: PartnerSetting): Promise<string> {
+    if (partnerSetting.setting?.category) {
+      return partnerSetting.setting.category
+    }
+
+    return (await getRepository(Setting).findOneBy({ id: partnerSetting.settingId }))?.category
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() partnerSetting: PartnerSetting): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: partnerSetting.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() partnerSetting: PartnerSetting): Promise<User> {
+    return await getRepository(User).findOneBy({ id: partnerSetting.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() partnerSetting: PartnerSetting): Promise<User> {
+    return await getRepository(User).findOneBy({ id: partnerSetting.creatorId })
+  }
+}

package/server/service/partner-setting/partner-setting-type.ts

@@ -0,0 +1,42 @@
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+import { ObjectRef } from '@things-factory/shell'
+import { PartnerSetting } from './partner-setting'
+
+@InputType()
+export class NewPartnerSetting {
+  @Field(type => ObjectRef)
+  partnerDomain: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  setting: ObjectRef
+
+  @Field({ nullable: true })
+  value?: string
+}
+
+@InputType()
+export class PartnerSettingPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field(type => ObjectRef, { nullable: true })
+  partnerDomain: ObjectRef
+
+  @Field(type => ObjectRef, { nullable: true })
+  setting: ObjectRef
+
+  @Field({ nullable: true })
+  value?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class PartnerSettingList {
+  @Field(type => [PartnerSetting])
+  items: PartnerSetting[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/partner-setting/partner-setting.ts

@@ -0,0 +1,109 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  EntityManager,
+  getRepository,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  Repository,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+import { Setting } from '../setting/setting'
+
+@Entity()
+@Index(
+  'ix_partner_setting_0',
+  partnerSetting => [partnerSetting.domain, partnerSetting.partnerDomain, partnerSetting.setting],
+  { unique: true }
+)
+@ObjectType({ description: 'Entity for PartnerSetting' })
+export class PartnerSetting {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field(type => Domain)
+  domain?: Domain
+
+  @RelationId((partnerSetting: PartnerSetting) => partnerSetting.domain)
+  domainId?: string
+
+  @ManyToOne(type => Domain, { nullable: false })
+  @Field(type => Domain, { nullable: true })
+  partnerDomain: Domain
+
+  @RelationId((partnerSetting: PartnerSetting) => partnerSetting.partnerDomain)
+  @Field({ nullable: true })
+  partnerDomainId?: string
+
+  @ManyToOne(type => Setting)
+  @Field({ nullable: true })
+  setting: Setting
+
+  @RelationId((partnerSetting: PartnerSetting) => partnerSetting.setting)
+  @Field({ nullable: true })
+  settingId?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  value?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  category?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((partnerSetting: PartnerSetting) => partnerSetting.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((partnerSetting: PartnerSetting) => partnerSetting.updater)
+  updaterId?: string
+
+  static async get(domain: Domain, partnerDomain: Domain, name: string, tx?: EntityManager): Promise<string> {
+    const partnerSettingRepo: Repository<PartnerSetting> =
+      tx?.getRepository(PartnerSetting) || getRepository(PartnerSetting)
+    const settingRepo: Repository<Setting> = tx?.getRepository(Setting) || getRepository(Setting)
+    const setting: Setting = await settingRepo.findOneBy({ domain: { id: domain.id }, name })
+
+    if (!setting) throw new Error(`No setting found has '${name}' as its name`)
+
+    const domainSetting: PartnerSetting = await partnerSettingRepo.findOneBy({
+      domain: { id: domain.id },
+      partnerDomain: { id: partnerDomain.id },
+      setting: { id: setting.id }
+    })
+
+    return domainSetting?.value || setting?.value
+  }
+}

package/server/service/setting/index.ts

@@ -0,0 +1,6 @@
+import { Setting } from './setting'
+import { SettingQuery } from './setting-query'
+import { SettingMutation } from './setting-mutation'
+
+export const entities = [Setting]
+export const resolvers = [SettingQuery, SettingMutation]

package/server/service/setting/setting-mutation.ts

@@ -0,0 +1,118 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Setting } from './setting'
+import { NewSetting, SettingPatch } from './setting-type'
+
+@Resolver(Setting)
+export class SettingMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "setting", privilege: "mutation")')
+  @Mutation(returns => Setting, { description: 'To create new Setting' })
+  async createSetting(@Arg('setting') setting: NewSetting, @Ctx() context: ResolverContext): Promise<Setting> {
+    const { tx, domain, user } = context.state
+    return await tx.getRepository(Setting).save({
+      domain,
+      ...setting,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "setting", privilege: "mutation")')
+  @Mutation(returns => Setting, { description: 'To modify Setting information' })
+  async updateSetting(
+    @Arg('name') name: string,
+    @Arg('patch') patch: SettingPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Setting> {
+    const { tx, domain, user } = context.state
+
+    const repository = tx.getRepository(Setting)
+    const setting = await repository.findOneBy({ domain: { id: domain.id }, name })
+
+    return await repository.save({
+      name,
+      creater: user,
+      ...setting,
+      ...patch,
+      domain,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "setting", privilege: "mutation")')
+  @Mutation(returns => [Setting], { description: "To modify multiple Settings' information" })
+  async updateMultipleSetting(
+    @Arg('patches', type => [SettingPatch]) patches: SettingPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Setting[]> {
+    const { tx, domain, user } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const settingRepo = tx.getRepository(Setting)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await settingRepo.save({
+          domain: { id: domain.id },
+          creator: user,
+          updater: user,
+          ...newRecord
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const setting = await settingRepo.findOneBy({ id: newRecord.id })
+
+        const result = await settingRepo.save({
+          ...setting,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "setting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete Setting' })
+  async deleteSetting(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { tx, domain } = context.state
+
+    await tx.getRepository(Setting).delete({ domain: { id: domain.id }, name })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "setting", privilege: "mutation")')
+  @Mutation(returns => Boolean, { description: 'To delete multiple settings' })
+  async deleteSettings(
+    @Arg('names', type => [String]) names: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { tx, domain } = context.state
+
+    await tx.getRepository(Setting).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+
+    return true
+  }
+}

package/server/service/setting/setting-query.ts

@@ -0,0 +1,88 @@
+import { Arg, Args, Ctx, Directive, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getRepository, ListParam, getQueryBuilderFromListParams } from '@things-factory/shell'
+
+import { PartnerSetting } from '../partner-setting/partner-setting'
+import { Setting } from './setting'
+import { SettingList } from './setting-type'
+
+@Resolver(Setting)
+export class SettingQuery {
+  @Directive('@privilege(category: "setting", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => Setting, { description: 'To fetch a Setting' })
+  async setting(
+    @Arg('name') name: string,
+    @Arg('partnerDomainId', { nullable: true }) partnerDomainId: string,
+    @Ctx() context: ResolverContext
+  ): Promise<Setting> {
+    const { domain } = context.state
+
+    let setting: Setting = await getRepository(Setting).findOne({ where: { domain: { id: domain.id }, name } })
+    if (!setting) throw new Error(`${name} setting not found`)
+
+    if (partnerDomainId) {
+      const partnerDomain: Domain = await getRepository(Domain).findOneBy({ id: partnerDomainId })
+      const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOneBy({
+        setting: { id: setting.id },
+        domain: { id: domain.id },
+        partnerDomain: { id: partnerDomain.id }
+      })
+      if (partnerSetting) setting.value = partnerSetting.value
+    }
+
+    return setting
+  }
+
+  @Directive('@privilege(category: "setting", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => SettingList, { description: 'To fetch multiple Settings' })
+  async settings(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<SettingList> {
+    const { domain } = context.state
+    const queryBuilder = getQueryBuilderFromListParams({
+      repository: getRepository(Setting),
+      params,
+      domain,
+      searchables: ['name', 'description', 'category']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+    return { items, total }
+  }
+
+  // @FieldResolver(type => Domain)
+  // async value(@Root() setting: Setting, @Ctx() context: ResolverContext) {
+  //   const { user, domain } = context.state
+  //   const userDomains: Domain[] = user.domains
+  //   let value: string = setting.value
+
+  //   const partner: Partner = await getRepository(Partner).findOne({
+  //     where: { domain: { id: domain.id }, partnerDomain: { id: In(userDomains.map((userDomain: Domain) => userDomain.id)) } },
+  //     relations: ['partnerDomain']
+  //   })
+  //   if (partner?.partnerDomain) {
+  //     const partnerSetting: PartnerSetting = await getRepository(PartnerSetting).findOne({
+  //       setting,
+  //       domain,
+  //       partnerDomain: partner.partnerDomain
+  //     })
+  //     if (partnerSetting) value = partnerSetting.value
+  //   }
+
+  //   return value
+  // }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() setting: Setting) {
+    return await getRepository(Domain).findOneBy({ id: setting.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() setting: Setting): Promise<User> {
+    return await getRepository(User).findOneBy({ id: setting.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() setting: Setting): Promise<User> {
+    return await getRepository(User).findOneBy({ id: setting.creatorId })
+  }
+}