@things-factory/routing-base 5.0.15 → 6.0.0-alpha.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/routing-base",
-  "version": "5.0.15",
+  "version": "6.0.0-alpha.10",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,9 +24,9 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/attachment-base": "^5.0.15",
-    "@things-factory/auth-base": "^5.0.15",
-    "@things-factory/shell": "^5.0.15"
+    "@things-factory/attachment-base": "^6.0.0-alpha.10",
+    "@things-factory/auth-base": "^6.0.0-alpha.10",
+    "@things-factory/shell": "^6.0.0-alpha.8"
   },
-  "gitHead": "87b738da786f92983d009d72548918be93e4ae2c"
+  "gitHead": "9ec9c564e157ebe830839e5a9cf8cfd6ec4e44b1"
 }

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

@@ -10,7 +10,10 @@ import { NewOperation, OperationPatch } from './operation-type'
 export class OperationMutation {
   @Directive('@transaction')
   @Mutation(returns => Operation, { description: 'To create new Operation' })
-  async createOperation(@Arg('operation') operation: NewOperation, @Ctx() context: any): Promise<Operation> {
+  async createOperation(
+    @Arg('operation') operation: NewOperation,
+    @Ctx() context: ResolverContext
+  ): Promise<Operation> {
     const { domain, user, tx } = context.state
 
     const result = await tx.getRepository(Operation).save({
@@ -42,13 +45,13 @@ export class OperationMutation {
   async updateOperation(
     @Arg('id') id: string,
     @Arg('patch') patch: OperationPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Operation> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Operation)
     const operation = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     const result = await repository.save({
@@ -80,7 +83,7 @@ export class OperationMutation {
   @Mutation(returns => [Operation], { description: "To modify multiple Operations' information" })
   async updateMultipleOperation(
     @Arg('patches', type => [OperationPatch]) patches: OperationPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Operation[]> {
     const { domain, user, tx } = context.state
 
@@ -121,7 +124,7 @@ export class OperationMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const operation = await operationRepo.findOne(newRecord.id)
+        const operation = await operationRepo.findOneBy({ id: newRecord.id })
 
         const result = await operationRepo.save({
           ...operation,
@@ -153,10 +156,10 @@ export class OperationMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete Operation' })
-  async deleteOperation(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteOperation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Operation).delete({ domain, id })
+    await tx.getRepository(Operation).delete({ domain: { id: domain.id }, id })
     await deleteAttachmentsByRef(null, { refBys: [id] }, context)
 
     return true
@@ -164,11 +167,14 @@ export class OperationMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple operations' })
-  async deleteOperations(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteOperations(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Operation).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

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

@@ -1,9 +1,8 @@
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
 
 import { Attachment } from '@things-factory/attachment-base'
 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 { Operation } from './operation'
 import { OperationList } from './operation-type'
@@ -11,16 +10,16 @@ import { OperationList } from './operation-type'
 @Resolver(Operation)
 export class OperationQuery {
   @Query(returns => Operation, { description: 'To fetch a Operation' })
-  async operation(@Arg('id') id: string, @Ctx() context: any): Promise<Operation> {
+  async operation(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Operation> {
     const { domain } = context.state
 
     return await getRepository(Operation).findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => OperationList, { description: 'To fetch multiple Operations' })
-  async operations(@Args() params: ListParam, @Ctx() context: any): Promise<OperationList> {
+  async operations(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<OperationList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -37,24 +36,24 @@ export class OperationQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() operation: Operation): Promise<Domain> {
-    return await getRepository(Domain).findOne(operation.domainId)
+    return await getRepository(Domain).findOneBy({ id: operation.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() operation: Operation): Promise<User> {
-    return await getRepository(User).findOne(operation.updaterId)
+    return await getRepository(User).findOneBy({ id: operation.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() operation: Operation): Promise<User> {
-    return await getRepository(User).findOne(operation.creatorId)
+    return await getRepository(User).findOneBy({ id: operation.creatorId })
   }
 
   @FieldResolver(type => String)
   async thumbnail(@Root() operation: Operation): Promise<string | undefined> {
     const attachment: Attachment = await getRepository(Attachment).findOne({
       where: {
-        domain: operation.domainId,
+        domain: { id: operation.domainId },
         refBy: operation.id
       }
     })

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

@@ -1,5 +1,6 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { getRepository, In } from 'typeorm'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
 import { Routing } from './routing'
 import { NewRouting, RoutingPatch } from './routing-type'
 
@@ -7,7 +8,7 @@ import { NewRouting, RoutingPatch } from './routing-type'
 export class RoutingMutation {
   @Directive('@transaction')
   @Mutation(returns => Routing, { description: 'To create new Routing' })
-  async createRouting(@Arg('routing') routing: NewRouting, @Ctx() context: any): Promise<Routing> {
+  async createRouting(@Arg('routing') routing: NewRouting, @Ctx() context: ResolverContext): Promise<Routing> {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(Routing).save({
@@ -23,13 +24,13 @@ export class RoutingMutation {
   async updateRouting(
     @Arg('id') id: string,
     @Arg('patch') patch: RoutingPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Routing> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(Routing)
     const routing = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
@@ -43,7 +44,7 @@ export class RoutingMutation {
   @Mutation(returns => [Routing], { description: "To modify multiple Routings' information" })
   async updateMultipleRouting(
     @Arg('patches', type => [RoutingPatch]) patches: RoutingPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<Routing[]> {
     const { domain, user, tx } = context.state
 
@@ -70,7 +71,7 @@ export class RoutingMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const routing = await routingRepo.findOne(newRecord.id)
+        const routing = await routingRepo.findOneBy({ id: newRecord.id })
 
         const result = await routingRepo.save({
           ...routing,
@@ -87,23 +88,20 @@ export class RoutingMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete Routing' })
-  async deleteRouting(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteRouting(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(Routing).delete({ domain, id })
+    await tx.getRepository(Routing).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple routings' })
-  async deleteRoutings(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: any
-  ): Promise<boolean> {
+  async deleteRoutings(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(Routing).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

package/server/service/routing/routing-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 { Operation } from '../operation/operation'
 import { Routing } from './routing'
@@ -11,16 +10,16 @@ import { RoutingList } from './routing-type'
 @Resolver(Routing)
 export class RoutingQuery {
   @Query(returns => Routing, { description: 'To fetch a Routing' })
-  async routing(@Arg('id') id: string, @Ctx() context: any): Promise<Routing> {
+  async routing(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Routing> {
     const { domain } = context.state
 
     return await getRepository(Routing).findOne({
-      where: { domain, name }
+      where: { domain: { id: domain.id }, id }
     })
   }
 
   @Query(returns => RoutingList, { description: 'To fetch multiple Routings' })
-  async routings(@Args() params: ListParam, @Ctx() context: any): Promise<RoutingList> {
+  async routings(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<RoutingList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -37,21 +36,21 @@ export class RoutingQuery {
 
   @FieldResolver(type => Domain)
   async domain(@Root() routing: Routing): Promise<Domain> {
-    return await getRepository(Domain).findOne(routing.domainId)
+    return await getRepository(Domain).findOneBy({ id: routing.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() routing: Routing): Promise<User> {
-    return await getRepository(User).findOne(routing.updaterId)
+    return await getRepository(User).findOneBy({ id: routing.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() routing: Routing): Promise<User> {
-    return await getRepository(User).findOne(routing.creatorId)
+    return await getRepository(User).findOneBy({ id: routing.creatorId })
   }
 }
 
-export async function firstOperation(routingId: string, context: any): Promise<Operation> {
+export async function firstOperation(routingId: string, context: ResolverContext): Promise<Operation> {
   const { domain, user, tx } = context.state
   const operation: Operation = await tx.getRepository(Operation).query(
     `
@@ -84,7 +83,11 @@ export async function firstOperation(routingId: string, context: any): Promise<O
   return operation
 }
 
-export async function nextOperation(operationId: string, routingId: string, context: any): Promise<Operation> {
+export async function nextOperation(
+  operationId: string,
+  routingId: string,
+  context: ResolverContext
+): Promise<Operation> {
   const operation = await getRepository(Operation).query(
     `
         select 
@@ -128,7 +131,11 @@ export async function nextOperation(operationId: string, routingId: string, cont
   return operation
 }
 
-export async function prevOperation(operationId: string, routingId: string, context: any): Promise<Operation> {
+export async function prevOperation(
+  operationId: string,
+  routingId: string,
+  context: ResolverContext
+): Promise<Operation> {
   const operation = await getRepository(Operation).query(
     `
         select 
@@ -173,7 +180,7 @@ export async function prevOperation(operationId: string, routingId: string, cont
   return operation
 }
 
-export async function lastOperation(routingId: string, context: any): Promise<Operation> {
+export async function lastOperation(routingId: string, context: ResolverContext): Promise<Operation> {
   const operation = await getRepository(Operation).query(
     `
         select 

package/server/service/routing-item/routing-item-mutation.ts

@@ -1,23 +1,17 @@
-import {
-  Arg,
-  Ctx,
-  Directive,
-  Mutation,
-  Resolver
-} from 'type-graphql'
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
 
 import { RoutingItem } from './routing-item'
-import {
-  NewRoutingItem,
-  RoutingItemPatch
-} from './routing-item-type'
+import { NewRoutingItem, RoutingItemPatch } from './routing-item-type'
 
 @Resolver(RoutingItem)
 export class RoutingItemMutation {
   @Directive('@transaction')
   @Mutation(returns => RoutingItem, { description: 'To create new RoutingItem' })
-  async createRoutingItem(@Arg('routingItem') routingItem: NewRoutingItem, @Ctx() context: any): Promise<RoutingItem> {
+  async createRoutingItem(
+    @Arg('routingItem') routingItem: NewRoutingItem,
+    @Ctx() context: ResolverContext
+  ): Promise<RoutingItem> {
     const { domain, user, tx } = context.state
 
     return await tx.getRepository(RoutingItem).save({
@@ -33,13 +27,13 @@ export class RoutingItemMutation {
   async updateRoutingItem(
     @Arg('id') id: string,
     @Arg('patch') patch: RoutingItemPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<RoutingItem> {
     const { domain, user, tx } = context.state
 
     const repository = tx.getRepository(RoutingItem)
     const routingItem = await repository.findOne({
-      where: { domain, id }
+      where: { domain: { id: domain.id }, id }
     })
 
     return await repository.save({
@@ -53,7 +47,7 @@ export class RoutingItemMutation {
   @Mutation(returns => [RoutingItem], { description: "To modify multiple RoutingItems' information" })
   async updateMultipleRoutingItem(
     @Arg('patches', type => [RoutingItemPatch]) patches: RoutingItemPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<RoutingItem[]> {
     const { domain, user, tx } = context.state
 
@@ -80,7 +74,7 @@ export class RoutingItemMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const routingItem = await routingItemRepo.findOne(newRecord.id)
+        const routingItem = await routingItemRepo.findOneBy({ id: newRecord.id })
 
         const result = await routingItemRepo.save({
           ...routingItem,
@@ -97,20 +91,23 @@ export class RoutingItemMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete RoutingItem' })
-  async deleteRoutingItem(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteRoutingItem(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { domain, tx } = context.state
 
-    await tx.getRepository(RoutingItem).delete({ domain, id })
+    await tx.getRepository(RoutingItem).delete({ domain: { id: domain.id }, id })
     return true
   }
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple routingItems' })
-  async deleteRoutingItems(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteRoutingItems(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { domain, tx } = context.state
 
     await tx.getRepository(RoutingItem).delete({
-      domain,
+      domain: { id: domain.id },
       id: In(ids)
     })
 

package/server/service/routing-item/routing-item-query.ts

@@ -1,8 +1,7 @@
 import { 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 { Operation } from '../operation/operation'
 import { Routing } from '../routing/routing'
@@ -12,7 +11,7 @@ import { RoutingItemList } from './routing-item-type'
 @Resolver(RoutingItem)
 export class RoutingItemQuery {
   @Query(returns => RoutingItemList, { description: 'To fetch multiple RoutingItems' })
-  async routingItems(@Args() params: ListParam, @Ctx() context: any): Promise<RoutingItemList> {
+  async routingItems(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<RoutingItemList> {
     const { domain } = context.state
 
     const queryBuilder = getQueryBuilderFromListParams({
@@ -33,26 +32,26 @@ export class RoutingItemQuery {
 
   @FieldResolver(type => Routing)
   async routing(@Root() routingItem: RoutingItem): Promise<Routing> {
-    return routingItem.routing || (await getRepository(Routing).findOne(routingItem.routingId))
+    return routingItem.routing || (await getRepository(Routing).findOneBy({ id: routingItem.routingId }))
   }
 
   @FieldResolver(type => Operation)
   async operation(@Root() routingItem: RoutingItem): Promise<Operation> {
-    return routingItem.operation || (await getRepository(Operation).findOne(routingItem.operationId))
+    return routingItem.operation || (await getRepository(Operation).findOneBy({ id: routingItem.operationId }))
   }
 
   @FieldResolver(type => Domain)
   async domain(@Root() routingItem: RoutingItem): Promise<Domain> {
-    return await getRepository(Domain).findOne(routingItem.domainId)
+    return await getRepository(Domain).findOneBy({ id: routingItem.domainId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() routingItem: RoutingItem): Promise<User> {
-    return await getRepository(User).findOne(routingItem.updaterId)
+    return await getRepository(User).findOneBy({ id: routingItem.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() routingItem: RoutingItem): Promise<User> {
-    return await getRepository(User).findOne(routingItem.creatorId)
+    return await getRepository(User).findOneBy({ id: routingItem.creatorId })
   }
 }