@things-factory/setting-base 8.0.5 → 9.0.0-beta.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/setting-base",
-  "version": "8.0.5",
+  "version": "9.0.0-beta.12",
   "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.5",
-    "@things-factory/code-base": "^8.0.5"
+    "@things-factory/auth-base": "^9.0.0-beta.12",
+    "@things-factory/code-base": "^9.0.0-beta.12"
   },
-  "gitHead": "9ab6fca18eeb58b9d2f3411661508a39d0ab6aee"
+  "gitHead": "5e9ade1c2d4b4c96b89396e36c3afa1caaf18ef0"
 }

package/client/actions/setting.ts

@@ -1,3 +0,0 @@
-export const ADD_SETTING = 'ADD_SETTING'
-export const REMOVE_SETTING = 'REMOVE_SETTING'
-export const ADD_REFRESH_HANDLER = 'ADD_REFRESH_HANDLER'

package/client/bootstrap.ts

@@ -1,8 +0,0 @@
-import { store } from '@operato/shell'
-import setting from './reducers/setting'
-
-export default function bootstrap() {
-  store.addReducers({
-    setting
-  })
-}

package/client/index.ts

@@ -1,2 +0,0 @@
-export * from './actions/setting'
-export * from './layout/settinglet'

package/client/layout/settinglet.ts

@@ -1,43 +0,0 @@
-import { LitElement, html, css } from 'lit'
-import { customElement, query, state } from 'lit/decorators.js'
-
-@customElement('setting-let')
-export class SettingLet extends LitElement {
-  static styles = [
-    css`
-      :host {
-        display: block;
-        margin: var(--setting-let-margin);
-        padding: var(--setting-content-padding);
-        background-color: var(--md-sys-color-on-primary);
-        border-radius: var(--setting-let-border-radius);
-        border: var(--setting-let-border);
-        text-transform: capitalize;
-      }
-
-      slot {
-        display: block;
-      }
-      slot[name='title'] {
-        margin-bottom: var(--spacing-medium);
-        border-bottom: 1px dotted rgba(var(--md-sys-color-primary), 0.5);
-      }
-      slot[name='title']::slotted(*) {
-        color: var(--md-sys-color-primary);
-        font: var(--setting-title-font);
-      }
-
-      slot[name='content']::slotted(*) {
-        color: var(--md-sys-color-on-surface);
-        font: var(--setting-content-font);
-      }
-    `
-  ]
-
-  render() {
-    return html`
-      <slot name="title"></slot>
-      <slot name="content"></slot>
-    `
-  }
-}

package/client/reducers/setting.ts

@@ -1,33 +0,0 @@
-import { ADD_SETTING, REMOVE_SETTING, ADD_REFRESH_HANDLER } from '../actions/setting'
-
-const INITIAL_STATE = {
-  settings: [],
-  refreshHandlers: []
-}
-
-const setting = (state = INITIAL_STATE, action) => {
-  switch (action.type) {
-    case ADD_SETTING:
-      return {
-        ...state,
-        settings: [...state.settings, action.setting]
-      }
-
-    case REMOVE_SETTING:
-      return {
-        ...state,
-        settings: state.settings.filter(i => i !== action.setting)
-      }
-
-    case ADD_REFRESH_HANDLER:
-      return {
-        ...state,
-        refreshHandlers: [...state.refreshHandlers, action.refreshHandler]
-      }
-
-    default:
-      return state
-  }
-}
-
-export default setting

package/server/index.ts

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

package/server/migrations/index.ts

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

@@ -1,25 +0,0 @@
-/* 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

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

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

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

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

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

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

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