@things-factory/code-base 8.0.37 → 9.0.0-9.0.0-beta.59.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/code-base",
-  "version": "8.0.37",
+  "version": "9.0.0-9.0.0-beta.59.0",
   "main": "dist-server/index.js",
   "browser": "dist-client/index.js",
   "things-factory": true,
@@ -27,9 +27,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@operato/graphql": "^8.0.0",
-    "@things-factory/auth-base": "^8.0.37",
-    "@things-factory/shell": "^8.0.37"
+    "@operato/graphql": "^9.0.0-beta",
+    "@things-factory/auth-base": "^9.0.0-9.0.0-beta.59.0",
+    "@things-factory/shell": "^9.0.0-9.0.0-beta.59.0"
   },
-  "gitHead": "a3a78656259d6c5d3719ba0864d6bdde87bcba7d"
+  "gitHead": "cf6ee84b991f469a4e71198b0e6314b45e9e10b8"
 }

package/client/codes-getter.ts

@@ -1,53 +0,0 @@
-import { client } from '@operato/graphql'
-import gql from 'graphql-tag'
-
-export const getCodeByName = async function (name) {
-  if (!name) throw new Error('name is undefined')
-
-  const response = await client.query({
-    query: gql`
-      query commonCode($name: String!) {
-        commonCode(name: $name) {
-          details {
-            rank
-            name
-            description
-          }
-        }
-      }
-    `,
-    variables: { name }
-  })
-
-  if (!response.errors && response.data.commonCode && response.data.commonCode.details) {
-    return response.data.commonCode.details.sort((a, b) => a.rank - b.rank)
-  } else {
-    return []
-  }
-}
-
-/* TODO move to operato-wms module */
-export const getPartnerCodeByName = async function (name, partnerDomainId) {
-  if (!name || !partnerDomainId) throw new Error('parameter is undefined')
-
-  const response = await client.query({
-    query: gql`
-      query partnerCommonCode($name: String!, $partnerDomainId: String!) {
-        partnerCommonCode(name: $name, partnerDomainId: $partnerDomainId) {
-          details {
-            rank
-            name
-            description
-          }
-        }
-      }
-    `,
-    variables: { name, partnerDomainId }
-  })
-
-  if (!response.errors && response.data.partnerCommonCode && response.data.partnerCommonCode.details) {
-    return response.data.partnerCommonCode.details.sort((a, b) => a.rank - b.rank)
-  } else {
-    return []
-  }
-}

package/client/index.ts

@@ -1 +0,0 @@
-export * from './codes-getter'

package/server/index.ts

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

package/server/service/common-code/common-code-mutation.ts

@@ -1,152 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { CommonCodeDetail } from '../common-code-detail/common-code-detail'
-import { CommonCode } from './common-code'
-import { CommonCodePatch, NewCommonCode } from './common-code-type'
-
-@Resolver(CommonCode)
-export class CommonCodeMutation {
-  @Directive('@transaction')
-  @Mutation(returns => CommonCode, { description: 'To create new CommonCode' })
-  async createCommonCode(
-    @Arg('commonCode') commonCode: NewCommonCode,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCode> {
-    const { domain, user, tx } = context.state
-
-    const details = await getRepository(CommonCodeDetail).findByIds(commonCode.details || [])
-
-    return await tx.getRepository(CommonCode).save({
-      ...commonCode,
-      details,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => CommonCode, { description: 'To modify CommonCode information' })
-  async updateCommonCode(
-    @Arg('name') name: string,
-    @Arg('patch') patch: CommonCodePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCode> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(CommonCode)
-    const commonCode = await repository.findOne({
-      where: { domain: { id: domain.id }, name },
-      relations: ['details']
-    })
-
-    const detailIds = commonCode.details.map(detail => detail.id)
-    if (patch.details && patch.details.length) {
-      patch.details.forEach((detailId: string) => {
-        if (!detailIds.includes(detailId)) {
-          detailIds.push(detailId)
-        }
-      })
-    }
-
-    return await repository.save({
-      ...commonCode,
-      ...patch,
-      details: await getRepository(CommonCodeDetail).findByIds(detailIds),
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [CommonCode], { description: "To modify multiple CommonCodes' information" })
-  async updateMultipleCommonCode(
-    @Arg('patches', type => [CommonCodePatch]) patches: CommonCodePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCode[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const commonCodeRepo = tx.getRepository(CommonCode)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await commonCodeRepo.save({
-          ...(newRecord as any),
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const commonCode = await commonCodeRepo.findOneBy({ id: newRecord.id })
-
-        const result = await commonCodeRepo.save({
-          ...commonCode,
-          ...(newRecord as any),
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete CommonCode' })
-  async deleteCommonCode(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(CommonCode).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple CommonCodes' })
-  async deleteCommonCodes(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(CommonCode).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple CommonCodes' })
-  async importCommonCodes(
-    @Arg('commonCodes', type => [CommonCodePatch]) commonCodes: CommonCodePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      commonCodes.map(async (commonCode: CommonCodePatch) => {
-        const createdCommonCode: CommonCode = await tx
-          .getRepository(CommonCode)
-          .save({ domain, ...(commonCode as any) })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/common-code/common-code-query.ts

@@ -1,74 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { CommonCodeDetail } from '../common-code-detail/common-code-detail'
-import { CommonCode } from './common-code'
-import { CommonCodeList } from './common-code-type'
-
-@Resolver(CommonCode)
-export class CommonCodeQuery {
-  @Query(returns => CommonCode!, { nullable: true, description: 'To fetch a CommonCode' })
-  async commonCode(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<CommonCode> {
-    const { domain } = context.state
-
-    return await getRepository(CommonCode).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, name }
-    })
-  }
-
-  @Query(returns => CommonCodeList, { description: 'To fetch multiple CommonCodes' })
-  async commonCodes(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCodeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(CommonCode),
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  /* TODO move to operato-wms module */
-  @Query(returns => CommonCode, { description: "To fetch specific domain's CommonCodes by given name" })
-  async partnerCommonCode(
-    @Arg('name') name: string,
-    @Arg('partnerDomainId') partnerDomainId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCode> {
-    return await getRepository(CommonCode).findOne({
-      where: { domain: { id: partnerDomainId }, name }
-    })
-  }
-
-  @FieldResolver(type => [CommonCodeDetail])
-  async details(@Root() commonCode: CommonCode): Promise<CommonCodeDetail[]> {
-    return await getRepository(CommonCodeDetail).findBy({
-      commonCode: { id: commonCode.id }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() commonCode: CommonCode): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: commonCode.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() commonCode: CommonCode): Promise<User> {
-    return await getRepository(User).findOneBy({ id: commonCode.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() commonCode: CommonCode): Promise<User> {
-    return await getRepository(User).findOneBy({ id: commonCode.creatorId })
-  }
-}

package/server/service/common-code/common-code-type.ts

@@ -1,42 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { CommonCode } from './common-code'
-
-@InputType()
-export class NewCommonCode {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => [String], { nullable: true })
-  details?: string[]
-}
-
-@InputType()
-export class CommonCodePatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => [String], { nullable: true })
-  details?: string[]
-
-  @Field({ nullable: true })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class CommonCodeList {
-  @Field(type => [CommonCode])
-  items: CommonCode[]
-
-  @Field(type => Int)
-  total: number
-}

package/server/service/common-code/common-code.ts

@@ -1,73 +0,0 @@
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  OneToMany,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain } from '@things-factory/shell'
-
-import { CommonCodeDetail } from '../common-code-detail/common-code-detail'
-
-@Entity()
-@Index('ix_common_code_0', (commonCode: CommonCode) => [commonCode.domain, commonCode.name], { unique: true })
-@Index('ix_common_code_1', (commonCode: CommonCode) => [commonCode.domain]) /* TOBE-REMOVED */
-@ObjectType({ description: 'Entity for CommonCode' })
-export class CommonCode {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((commonCode: CommonCode) => commonCode.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @OneToMany(type => CommonCodeDetail, commonCodeDetail => commonCodeDetail.commonCode)
-  details: CommonCodeDetail[]
-
-  @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((commonCode: CommonCode) => commonCode.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((commonCode: CommonCode) => commonCode.updater)
-  updaterId?: string
-}

package/server/service/common-code/index.ts

@@ -1,6 +0,0 @@
-import { CommonCode } from './common-code'
-import { CommonCodeQuery } from './common-code-query'
-import { CommonCodeMutation } from './common-code-mutation'
-
-export const entities = [CommonCode]
-export const resolvers = [CommonCodeQuery, CommonCodeMutation]

package/server/service/common-code-detail/common-code-detail-mutation.ts

@@ -1,153 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { CommonCode } from '../common-code/common-code'
-import { CommonCodeDetail } from './common-code-detail'
-import { CommonCodeDetailPatch, NewCommonCodeDetail } from './common-code-detail-type'
-
-@Resolver(CommonCodeDetail)
-export class CommonCodeDetailMutation {
-  @Directive('@transaction')
-  @Mutation(returns => CommonCodeDetail, { description: 'To create new CommonCodeDetail' })
-  async createCommonCodeDetail(
-    @Arg('commonCodeDetail') commonCodeDetail: NewCommonCodeDetail,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCodeDetail> {
-    const { domain, user, tx } = context.state
-
-    if (commonCodeDetail && commonCodeDetail.commonCode.id) {
-      commonCodeDetail.commonCode = await tx.getRepository(CommonCode).findOneBy({ id: commonCodeDetail.commonCode.id })
-    }
-
-    return await tx.getRepository(CommonCodeDetail).save({
-      ...commonCodeDetail,
-      domain,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => CommonCodeDetail, { description: 'To modify CommonCodeDetail information' })
-  async updateCommonCodeDetail(
-    @Arg('id') id: string,
-    @Arg('patch') patch: CommonCodeDetailPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCodeDetail> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(CommonCodeDetail)
-    const commonCodeDetail = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    if (patch.commonCode && patch.commonCode.id) {
-      patch.commonCode = await tx.getRepository(CommonCode).findOneBy({ id: patch.commonCode.id })
-    }
-
-    return await repository.save({
-      ...commonCodeDetail,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [CommonCodeDetail], { description: "To modify multiple CommonCodeDetails' information" })
-  async updateMultipleCommonCodeDetail(
-    @Arg('patches', type => [CommonCodeDetailPatch]) patches: CommonCodeDetailPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCodeDetail[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const commonCodeRepo = tx.getRepository(CommonCode)
-    const commonCodeDetailRepo = tx.getRepository(CommonCodeDetail)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        if (newRecord.commonCode && newRecord.commonCode.id) {
-          newRecord.commonCode = await commonCodeRepo.findOneBy({ id: newRecord.commonCode.id })
-        }
-
-        const result = await commonCodeDetailRepo.save({
-          ...newRecord,
-          domain,
-          creator: user,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const commonCodeDetail = await commonCodeDetailRepo.findOneBy({ id: newRecord.id })
-
-        if (newRecord.commonCode && newRecord.commonCode.id) {
-          newRecord.commonCode = await commonCodeRepo.findOneBy({ id: newRecord.commonCode.id })
-        }
-
-        const result = await commonCodeDetailRepo.save({
-          ...commonCodeDetail,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete CommonCodeDetail' })
-  async deleteCommonCodeDetail(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(CommonCodeDetail).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple CommonCodeDetails' })
-  async deleteCommonCodeDetails(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(CommonCodeDetail).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To import multiple CommonCodeDetails' })
-  async importCommonCodeDetails(
-    @Arg('commonCodeDetails', type => [CommonCodeDetailPatch]) commonCodeDetails: CommonCodeDetailPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await Promise.all(
-      commonCodeDetails.map(async (commonCodeDetail: CommonCodeDetailPatch) => {
-        const createdCommonCodeDetail: CommonCodeDetail = await tx
-          .getRepository(CommonCodeDetail)
-          .save({ domain, ...commonCodeDetail })
-      })
-    )
-
-    return true
-  }
-}

package/server/service/common-code-detail/common-code-detail-query.ts

@@ -1,69 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { CommonCode } from '../common-code/common-code'
-import { CommonCodeDetail } from './common-code-detail'
-import { CommonCodeDetailList } from './common-code-detail-type'
-
-@Resolver(CommonCodeDetail)
-export class CommonCodeDetailQuery {
-  @Query(returns => CommonCodeDetail, { description: 'To fetch a CommonCodeDetail' })
-  async commonCodeDetail(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<CommonCodeDetail> {
-    const { domain } = context.state
-
-    return await getRepository(CommonCodeDetail).findOne({
-      where: { domain: { id: In([domain.id, domain.parentId].filter(Boolean)) }, id }
-    })
-  }
-
-  @Query(returns => CommonCodeDetailList, { description: 'To fetch multiple CommonCodeDetails' })
-  async commonCodeDetails(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<CommonCodeDetailList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(CommonCodeDetail),
-      alias: 'ccd',
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => String)
-  async commonCode(commonCodeDetail): Promise<CommonCode> {
-    return await getRepository(CommonCode).findOneBy({ id: commonCodeDetail.commonCodeId })
-  }
-
-  @FieldResolver(type => Domain)
-  async description(@Root() commonCodeDetail: CommonCodeDetail, @Ctx() context: ResolverContext): Promise<String> {
-    const { lng } = context.state
-    const { labels, description } = commonCodeDetail
-
-    return (lng && labels && labels[lng]) || description
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() commonCodeDetail: CommonCodeDetail): Promise<Domain> {
-    return await getRepository(Domain).findOneBy({ id: commonCodeDetail.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() commonCodeDetail: CommonCodeDetail): Promise<User> {
-    return await getRepository(User).findOneBy({ id: commonCodeDetail.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() commonCodeDetail: CommonCodeDetail): Promise<User> {
-    return await getRepository(User).findOneBy({ id: commonCodeDetail.creatorId })
-  }
-}