@things-factory/code-base 5.0.7 → 6.0.0-alpha.0

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { CommonCodeDetail } from '../common-code-detail/common-code-detail'
 import { CommonCode } from './common-code'
@@ -11,16 +10,16 @@ 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: any): Promise<CommonCode> {
+  async commonCode(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<CommonCode> {
     const { domain } = context.state
 
     return await getRepository(CommonCode).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, name }
     })
   }
 
   @Query(returns => CommonCodeList, { description: 'To fetch multiple CommonCodes' })
-  async commonCodes(@Args() params: ListParam, @Ctx() context: any): Promise<CommonCodeList> {
+  async commonCodes(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<CommonCodeList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -39,32 +38,32 @@ export class CommonCodeQuery {
   async partnerCommonCode(
     @Arg('name') name: string,
     @Arg('partnerDomainId') partnerDomainId: string,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CommonCode> {
     return await getRepository(CommonCode).findOne({
-      where: { domain: partnerDomainId, name }
+      where: { domain: { id: partnerDomainId }, name }
     })
   }
 
   @FieldResolver(type => [CommonCodeDetail])
   async details(@Root() commonCode: CommonCode): Promise<CommonCodeDetail[]> {
-    return await getRepository(CommonCodeDetail).find({
-      commonCode
+    return await getRepository(CommonCodeDetail).findBy({
+      commonCode: { id: commonCode.id }
     })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() commonCode: CommonCode): Promise<Domain> {
-    return await getRepository(Domain).findOne(commonCode.domainId)
+    return await getRepository(Domain).findOneBy({ id: commonCode.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() commonCode: CommonCode): Promise<User> {
-    return await getRepository(User).findOne(commonCode.updaterId)
+    return await getRepository(User).findOneBy({ id: commonCode.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() commonCode: CommonCode): Promise<User> {
-    return await getRepository(User).findOne(commonCode.creatorId)
+    return await getRepository(User).findOneBy({ id: commonCode.creatorId })
   }
 }

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

@@ -11,12 +11,12 @@ export class CommonCodeDetailMutation {
   @Mutation(returns => CommonCodeDetail, { description: 'To create new CommonCodeDetail' })
   async createCommonCodeDetail(
     @Arg('commonCodeDetail') commonCodeDetail: NewCommonCodeDetail,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CommonCodeDetail> {
     const { domain, user, tx } = context.state
 
     if (commonCodeDetail && commonCodeDetail.commonCode.id) {
-      commonCodeDetail.commonCode = await tx.getRepository(CommonCode).findOne(commonCodeDetail.commonCode.id)
+      commonCodeDetail.commonCode = await tx.getRepository(CommonCode).findOneBy({ id: commonCodeDetail.commonCode.id })
     }
 
     return await tx.getRepository(CommonCodeDetail).save({
@@ -32,17 +32,17 @@ export class CommonCodeDetailMutation {
   async updateCommonCodeDetail(
     @Arg('id') id: string,
     @Arg('patch') patch: CommonCodeDetailPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CommonCodeDetail> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(CommonCodeDetail)
     const commonCodeDetail = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     if (patch.commonCode && patch.commonCode.id) {
-      patch.commonCode = await tx.getRepository(CommonCode).findOne(patch.commonCode.id)
+      patch.commonCode = await tx.getRepository(CommonCode).findOneBy({ id: patch.commonCode.id })
     }
 
     return await repository.save({
@@ -56,7 +56,7 @@ export class CommonCodeDetailMutation {
   @Mutation(returns => [CommonCodeDetail], { description: "To modify multiple CommonCodeDetails' information" })
   async updateMultipleCommonCodeDetail(
     @Arg('patches', type => [CommonCodeDetailPatch]) patches: CommonCodeDetailPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<CommonCodeDetail[]> {
     const { domain, user, tx } = context.state
 
@@ -71,7 +71,7 @@ export class CommonCodeDetailMutation {
         const newRecord = _createRecords[i]
 
         if (newRecord.commonCode && newRecord.commonCode.id) {
-          newRecord.commonCode = await commonCodeRepo.findOne(newRecord.commonCode.id)
+          newRecord.commonCode = await commonCodeRepo.findOneBy({ id: newRecord.commonCode.id })
         }
 
         const result = await commonCodeDetailRepo.save({
@@ -88,10 +88,10 @@ export class CommonCodeDetailMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const commonCodeDetail = await commonCodeDetailRepo.findOne(newRecord.id)
+        const commonCodeDetail = await commonCodeDetailRepo.findOneBy({ id: newRecord.id })
 
         if (newRecord.commonCode && newRecord.commonCode.id) {
-          newRecord.commonCode = await commonCodeRepo.findOne(newRecord.commonCode.id)
+          newRecord.commonCode = await commonCodeRepo.findOneBy({ id: newRecord.commonCode.id })
         }
 
         const result = await commonCodeDetailRepo.save({
@@ -109,20 +109,23 @@ export class CommonCodeDetailMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete CommonCodeDetail' })
-  async deleteCommonCodeDetail(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteCommonCodeDetail(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(CommonCodeDetail).delete({ domain, id })
+    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: any): Promise<boolean> {
+  async deleteCommonCodeDetails(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(CommonCodeDetail).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 
@@ -133,7 +136,7 @@ export class CommonCodeDetailMutation {
   @Mutation(returns => Boolean, { description: 'To import multiple CommonCodeDetails' })
   async importCommonCodeDetails(
     @Arg('commonCodeDetails', type => [CommonCodeDetailPatch]) commonCodeDetails: CommonCodeDetailPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<boolean> {
     const { domain, tx } = context.state
 

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

@@ -1,8 +1,7 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { User } from '@things-factory/auth-base'
-import { Domain, getQueryBuilderFromListParams, ListParam } from '@things-factory/shell'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
 
 import { CommonCode } from '../common-code/common-code'
 import { CommonCodeDetail } from './common-code-detail'
@@ -11,16 +10,16 @@ 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: any): Promise<CommonCodeDetail> {
+  async commonCodeDetail(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<CommonCodeDetail> {
     const { domain } = context.state
 
     return await getRepository(CommonCodeDetail).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => CommonCodeDetailList, { description: 'To fetch multiple CommonCodeDetails' })
-  async commonCodeDetails(@Args() params: ListParam, @Ctx() context: any): Promise<CommonCodeDetailList> {
+  async commonCodeDetails(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<CommonCodeDetailList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -38,21 +37,21 @@ export class CommonCodeDetailQuery {
 
   @FieldResolver(type => CommonCode)
   async commonCode(commonCodeDetail): Promise<CommonCode> {
-    return await getRepository(CommonCode).findOne(commonCodeDetail.commonCodeId)
+    return await getRepository(CommonCode).findOneBy({ id: commonCodeDetail.commonCodeId })
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() commonCodeDetail: CommonCodeDetail): Promise<Domain> {
-    return await getRepository(Domain).findOne(commonCodeDetail.domainId)
+    return await getRepository(Domain).findOneBy({ id: commonCodeDetail.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() commonCodeDetail: CommonCodeDetail): Promise<User> {
-    return await getRepository(User).findOne(commonCodeDetail.updaterId)
+    return await getRepository(User).findOneBy({ id: commonCodeDetail.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() commonCodeDetail: CommonCodeDetail): Promise<User> {
-    return await getRepository(User).findOne(commonCodeDetail.creatorId)
+    return await getRepository(User).findOneBy({ id: commonCodeDetail.creatorId })
   }
 }