@things-factory/geography 5.0.7 → 6.0.0-alpha.0

package/server/service/geo-area/geo-area-query.ts

@@ -1,7 +1,8 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
 import { GeoCity } from '../geo-city/geo-city'
 import { GeoArea } from './geo-area'
 import { GeoAreaList } from './geo-area-type'
@@ -9,32 +10,65 @@ import { GeoAreaList } from './geo-area-type'
 @Resolver(GeoArea)
 export class GeoAreaQuery {
   @Query(returns => GeoArea, { description: 'To fetch a GeoArea' })
-  async geoArea(@Arg('id') id: string, @Ctx() context: any): Promise<GeoArea> {
+  async geoArea(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GeoArea> {
     return await getRepository(GeoArea).findOne({
       where: { id }
     })
   }
 
   @Query(returns => GeoAreaList, { description: 'To fetch multiple GeoAreas' })
-  async geoAreas(@Args() params: ListParam, @Ctx() context: any): Promise<GeoAreaList> {
+  async geoAreas(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<GeoAreaList> {
     const convertedParams = convertListParams(params)
     const [items, total] = await getRepository(GeoArea).findAndCount(convertedParams)
 
     return { items, total }
   }
 
+  @Query(returns => GeoAreaList)
+  async geoAreasAllPostCode(@Ctx() context: ResolverContext) {
+    const result = await getRepository(GeoArea)
+      .createQueryBuilder('ga')
+      .select('ga.postal_code')
+      .distinct(true)
+      .orderBy('ga.postal_code')
+      .getRawMany()
+
+    const items: any[] = result.map(item => {
+      return {
+        postalCode: item.postal_code
+      }
+    })
+
+    const total = items.length
+
+    return { items, total }
+  }
+
+  @Query(returns => GeoArea)
+  async geoAreasGetStateAndCityByPosCode(@Arg('postCode') postCode: string, @Ctx() context: ResolverContext) {
+    let result = await getRepository(GeoArea)
+      .createQueryBuilder('ga')
+      .select('ga.city_name', 'cityName')
+      .addSelect('ga.state_name', 'stateName')
+      .distinct(true)
+      .where('ga.postal_code = :postCode', { postCode: postCode })
+      .getRawOne()
+
+    return result
+  }
+
   @FieldResolver(type => GeoCity)
   async geoCity(@Root() geoArea: GeoArea): Promise<GeoCity> {
-    return await getRepository(GeoCity).findOne(geoArea.geoCityId)
+    return await getRepository(GeoCity).findOneBy({ id: geoArea.geoCityId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() geoArea: GeoArea): Promise<User> {
-    return await getRepository(User).findOne(geoArea.updaterId)
+    return await getRepository(User).findOneBy({ id: geoArea.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() geoArea: GeoArea): Promise<User> {
-    return await getRepository(User).findOne(geoArea.creatorId)
+    return await getRepository(User).findOneBy({ id: geoArea.creatorId })
   }
 }

package/server/service/geo-area/geo-area.ts

@@ -13,7 +13,7 @@ import {
 import { GeoCity } from '../geo-city/geo-city'
 
 @Entity()
-@Index('ix_geo_area_0', (geoArea: GeoArea) => [geoArea.geoCity, geoArea.name], { unique: true })
+@Index('ix_geo_area_0', (geoArea: GeoArea) => [geoArea.geoCity, geoArea.name, geoArea.postalCode,geoArea.stateName], { unique: true })
 @ObjectType({ description: 'Entity for GeoArea' })
 export class GeoArea {
   @PrimaryGeneratedColumn('uuid')

package/server/service/geo-city/geo-city-mutation.ts

@@ -1,5 +1,6 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
+
 import { GeoCity } from './geo-city'
 import { GeoCityPatch, NewGeoCity } from './geo-city-type'
 
@@ -7,7 +8,7 @@ import { GeoCityPatch, NewGeoCity } from './geo-city-type'
 export class GeoCityMutation {
   @Directive('@transaction')
   @Mutation(returns => GeoCity, { description: 'To create new GeoCity' })
-  async createGeoCity(@Arg('geoCity') geoCity: NewGeoCity, @Ctx() context: any): Promise<GeoCity> {
+  async createGeoCity(@Arg('geoCity') geoCity: NewGeoCity, @Ctx() context: ResolverContext): Promise<GeoCity> {
     const { user, tx } = context.state
 
     return await tx.getRepository(GeoCity).save({
@@ -19,7 +20,11 @@ export class GeoCityMutation {
 
   @Directive('@transaction')
   @Mutation(returns => GeoCity, { description: 'To modify GeoCity information' })
-  async updateGeoCity(@Arg('id') id: string, @Arg('patch') patch: GeoCityPatch, @Ctx() context: any): Promise<GeoCity> {
+  async updateGeoCity(
+    @Arg('id') id: string,
+    @Arg('patch') patch: GeoCityPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<GeoCity> {
     const { user, tx } = context.state
 
     const repository = tx.getRepository(GeoCity)
@@ -38,7 +43,7 @@ export class GeoCityMutation {
   @Mutation(returns => [GeoCity], { description: "To modify multiple GeoCities' information" })
   async updateMultipleGeoCity(
     @Arg('patches', type => [GeoCityPatch]) patches: GeoCityPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoCity[]> {
     const { user, tx } = context.state
 
@@ -64,7 +69,7 @@ export class GeoCityMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const geoCity = await geoCityRepo.findOne(newRecord.id)
+        const geoCity = await geoCityRepo.findOneBy({ id: newRecord.id })
 
         const result = await geoCityRepo.save({
           ...geoCity,
@@ -81,7 +86,7 @@ export class GeoCityMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete GeoCity' })
-  async deleteGeoCity(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteGeoCity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoCity).delete({ id })
@@ -90,7 +95,10 @@ export class GeoCityMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple geoCitys' })
-  async deleteGeoCities(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteGeoCities(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoCity).delete({

package/server/service/geo-city/geo-city-query.ts

@@ -1,7 +1,8 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
 import { GeoCountry } from '../geo-country/geo-country'
 import { GeoState } from '../geo-state/geo-state'
 import { GeoCity } from './geo-city'
@@ -10,14 +11,14 @@ import { GeoCityList } from './geo-city-type'
 @Resolver(GeoCity)
 export class GeoCityQuery {
   @Query(returns => GeoCity, { description: 'To fetch a GeoCity' })
-  async geoCity(@Arg('id') id: string, @Ctx() context: any): Promise<GeoCity> {
+  async geoCity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GeoCity> {
     return await getRepository(GeoCity).findOne({
       where: { id }
     })
   }
 
   @Query(returns => GeoCityList, { description: 'To fetch multiple GeoCities' })
-  async geoCities(@Args() params: ListParam, @Ctx() context: any): Promise<GeoCityList> {
+  async geoCities(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<GeoCityList> {
     const convertedParams = convertListParams(params)
     const [items, total] = await getRepository(GeoCity).findAndCount(convertedParams)
 
@@ -26,21 +27,21 @@ export class GeoCityQuery {
 
   @FieldResolver(type => GeoCountry)
   async geoCountry(@Root() geoCity: GeoCity): Promise<GeoCountry> {
-    return await getRepository(GeoCountry).findOne(geoCity.geoCountryId)
+    return await getRepository(GeoCountry).findOneBy({ id: geoCity.geoCountryId })
   }
 
   @FieldResolver(type => GeoState)
   async geoState(@Root() geoCity: GeoCity): Promise<GeoState> {
-    return await getRepository(GeoState).findOne(geoCity.geoStateId)
+    return await getRepository(GeoState).findOneBy({ id: geoCity.geoStateId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() geoCity: GeoCity): Promise<User> {
-    return await getRepository(User).findOne(geoCity.updaterId)
+    return await getRepository(User).findOneBy({ id: geoCity.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() geoCity: GeoCity): Promise<User> {
-    return await getRepository(User).findOne(geoCity.creatorId)
+    return await getRepository(User).findOneBy({ id: geoCity.creatorId })
   }
 }

package/server/service/geo-city/geo-city.ts

@@ -14,7 +14,7 @@ import { GeoCountry } from '../geo-country/geo-country'
 import { GeoState } from '../geo-state/geo-state'
 
 @Entity()
-@Index('ix_geo_city_0', (geoCity: GeoCity) => [geoCity.geoCountry, geoCity.name], { unique: true })
+@Index('ix_geo_city_0', (geoCity: GeoCity) => [geoCity.geoCountry, geoCity.name, geoCity.geoState], { unique: true })
 @ObjectType({ description: 'Entity for GeoCity' })
 export class GeoCity {
   @PrimaryGeneratedColumn('uuid')

package/server/service/geo-continent/geo-continent-mutation.ts

@@ -1,5 +1,6 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
+
 import { GeoContinent } from './geo-continent'
 import { GeoContinentPatch, NewGeoContinent } from './geo-continent-type'
 
@@ -9,7 +10,7 @@ export class GeoContinentMutation {
   @Mutation(returns => GeoContinent, { description: 'To create new GeoContinent' })
   async createGeoContinent(
     @Arg('geoContinent') geoContinent: NewGeoContinent,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoContinent> {
     const { user, tx } = context.state
 
@@ -25,7 +26,7 @@ export class GeoContinentMutation {
   async updateGeoContinent(
     @Arg('id') id: string,
     @Arg('patch') patch: GeoContinentPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoContinent> {
     const { user, tx } = context.state
 
@@ -45,7 +46,7 @@ export class GeoContinentMutation {
   @Mutation(returns => [GeoContinent], { description: "To modify multiple GeoContinents' information" })
   async updateMultipleGeoContinent(
     @Arg('patches', type => [GeoContinentPatch]) patches: GeoContinentPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoContinent[]> {
     const { user, tx } = context.state
 
@@ -71,7 +72,7 @@ export class GeoContinentMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const geoContinent = await geoContinentRepo.findOne(newRecord.id)
+        const geoContinent = await geoContinentRepo.findOneBy({ id: newRecord.id })
 
         const result = await geoContinentRepo.save({
           ...geoContinent,
@@ -88,7 +89,7 @@ export class GeoContinentMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete GeoContinent' })
-  async deleteGeoContinent(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteGeoContinent(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoContinent).delete({ id })
@@ -97,7 +98,10 @@ export class GeoContinentMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple geoContinents' })
-  async deleteGeoContinents(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteGeoContinents(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoContinent).delete({

package/server/service/geo-continent/geo-continent-query.ts

@@ -1,21 +1,22 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
 import { GeoContinent } from './geo-continent'
 import { GeoContinentList } from './geo-continent-type'
 
 @Resolver(GeoContinent)
 export class GeoContinentQuery {
   @Query(returns => GeoContinent, { description: 'To fetch a GeoContinent' })
-  async geoContinent(@Arg('id') id: string, @Ctx() context: any): Promise<GeoContinent> {
+  async geoContinent(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GeoContinent> {
     return await getRepository(GeoContinent).findOne({
       where: { id }
     })
   }
 
   @Query(returns => GeoContinentList, { description: 'To fetch multiple GeoContinents' })
-  async geoContinents(@Args() params: ListParam, @Ctx() context: any): Promise<GeoContinentList> {
+  async geoContinents(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<GeoContinentList> {
     const convertedParams = convertListParams(params)
     const [items, total] = await getRepository(GeoContinent).findAndCount(convertedParams)
 
@@ -24,11 +25,11 @@ export class GeoContinentQuery {
 
   @FieldResolver(type => User)
   async updater(@Root() geoContinent: GeoContinent): Promise<User> {
-    return await getRepository(User).findOne(geoContinent.updaterId)
+    return await getRepository(User).findOneBy({ id: geoContinent.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() geoContinent: GeoContinent): Promise<User> {
-    return await getRepository(User).findOne(geoContinent.creatorId)
+    return await getRepository(User).findOneBy({ id: geoContinent.creatorId })
   }
 }

package/server/service/geo-country/geo-country-mutation.ts

@@ -1,5 +1,6 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
+
 import { GeoCountry } from './geo-country'
 import { GeoCountryPatch, NewGeoCountry } from './geo-country-type'
 
@@ -7,7 +8,10 @@ import { GeoCountryPatch, NewGeoCountry } from './geo-country-type'
 export class GeoCountryMutation {
   @Directive('@transaction')
   @Mutation(returns => GeoCountry, { description: 'To create new GeoCountry' })
-  async createGeoCountry(@Arg('geoCountry') geoCountry: NewGeoCountry, @Ctx() context: any): Promise<GeoCountry> {
+  async createGeoCountry(
+    @Arg('geoCountry') geoCountry: NewGeoCountry,
+    @Ctx() context: ResolverContext
+  ): Promise<GeoCountry> {
     const { user, tx } = context.state
 
     return await tx.getRepository(GeoCountry).save({
@@ -22,7 +26,7 @@ export class GeoCountryMutation {
   async updateGeoCountry(
     @Arg('id') id: string,
     @Arg('patch') patch: GeoCountryPatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoCountry> {
     const { user, tx } = context.state
 
@@ -42,7 +46,7 @@ export class GeoCountryMutation {
   @Mutation(returns => [GeoCountry], { description: "To modify multiple GeoCountries' information" })
   async updateMultipleGeoCountry(
     @Arg('patches', type => [GeoCountryPatch]) patches: GeoCountryPatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoCountry[]> {
     const { user, tx } = context.state
 
@@ -68,7 +72,7 @@ export class GeoCountryMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const geoCountry = await geoCountryRepo.findOne(newRecord.id)
+        const geoCountry = await geoCountryRepo.findOneBy({ id: newRecord.id })
 
         const result = await geoCountryRepo.save({
           ...geoCountry,
@@ -85,7 +89,7 @@ export class GeoCountryMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete GeoCountry' })
-  async deleteGeoCountry(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteGeoCountry(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoCountry).delete({ id })
@@ -94,7 +98,10 @@ export class GeoCountryMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple geoCountrys' })
-  async deleteGeoCountries(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteGeoCountries(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoCountry).delete({

package/server/service/geo-country/geo-country-query.ts

@@ -1,7 +1,8 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
 import { GeoContinent } from '../geo-continent/geo-continent'
 import { GeoCountry } from './geo-country'
 import { GeoCountryList } from './geo-country-type'
@@ -9,32 +10,39 @@ import { GeoCountryList } from './geo-country-type'
 @Resolver(GeoCountry)
 export class GeoCountryQuery {
   @Query(returns => GeoCountry, { description: 'To fetch a GeoCountry' })
-  async geoCountry(@Arg('id') id: string, @Ctx() context: any): Promise<GeoCountry> {
+  async geoCountry(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GeoCountry> {
     return await getRepository(GeoCountry).findOne({
       where: { id }
     })
   }
 
   @Query(returns => GeoCountryList, { description: 'To fetch multiple GeoCountries' })
-  async geoCountries(@Args() params: ListParam, @Ctx() context: any): Promise<GeoCountryList> {
+  async geoCountries(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<GeoCountryList> {
     const convertedParams = convertListParams(params)
     const [items, total] = await getRepository(GeoCountry).findAndCount(convertedParams)
 
     return { items, total }
   }
 
+  @Query(returns => GeoCountryList, { description: 'To fetch multiple GeoCountries without params' })
+  async geoCountriesWithoutParam(@Ctx() context: ResolverContext): Promise<GeoCountryList> {
+    const [items, total] = await getRepository(GeoCountry).findAndCount()
+
+    return { items, total }
+  }
+
   @FieldResolver(type => GeoContinent)
   async geoContinent(@Root() geoCountry: GeoCountry): Promise<GeoContinent> {
-    return await getRepository(GeoContinent).findOne(geoCountry.geoContinentId)
+    return await getRepository(GeoContinent).findOneBy({ id: geoCountry.geoContinentId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() geoCountry: GeoCountry): Promise<User> {
-    return await getRepository(User).findOne(geoCountry.updaterId)
+    return await getRepository(User).findOneBy({ id: geoCountry.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() geoCountry: GeoCountry): Promise<User> {
-    return await getRepository(User).findOne(geoCountry.creatorId)
+    return await getRepository(User).findOneBy({ id: geoCountry.creatorId })
   }
 }

package/server/service/geo-state/geo-state-mutation.ts

@@ -1,5 +1,6 @@
 import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
 import { In } from 'typeorm'
+
 import { GeoState } from './geo-state'
 import { GeoStatePatch, NewGeoState } from './geo-state-type'
 
@@ -7,7 +8,7 @@ import { GeoStatePatch, NewGeoState } from './geo-state-type'
 export class GeoStateMutation {
   @Directive('@transaction')
   @Mutation(returns => GeoState, { description: 'To create new GeoState' })
-  async createGeoState(@Arg('geoState') geoState: NewGeoState, @Ctx() context: any): Promise<GeoState> {
+  async createGeoState(@Arg('geoState') geoState: NewGeoState, @Ctx() context: ResolverContext): Promise<GeoState> {
     const { user, tx } = context.state
 
     return await tx.getRepository(GeoState).save({
@@ -22,7 +23,7 @@ export class GeoStateMutation {
   async updateGeoState(
     @Arg('id') id: string,
     @Arg('patch') patch: GeoStatePatch,
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoState> {
     const { user, tx } = context.state
 
@@ -42,7 +43,7 @@ export class GeoStateMutation {
   @Mutation(returns => [GeoState], { description: "To modify multiple GeoStates' information" })
   async updateMultipleGeoState(
     @Arg('patches', type => [GeoStatePatch]) patches: GeoStatePatch[],
-    @Ctx() context: any
+    @Ctx() context: ResolverContext
   ): Promise<GeoState[]> {
     const { user, tx } = context.state
 
@@ -68,7 +69,7 @@ export class GeoStateMutation {
     if (_updateRecords.length > 0) {
       for (let i = 0; i < _updateRecords.length; i++) {
         const newRecord = _updateRecords[i]
-        const geoState = await geoStateRepo.findOne(newRecord.id)
+        const geoState = await geoStateRepo.findOneBy({ id: newRecord.id })
 
         const result = await geoStateRepo.save({
           ...geoState,
@@ -85,7 +86,7 @@ export class GeoStateMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete GeoState' })
-  async deleteGeoState(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+  async deleteGeoState(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoState).delete({ id })
@@ -94,7 +95,10 @@ export class GeoStateMutation {
 
   @Directive('@transaction')
   @Mutation(returns => Boolean, { description: 'To delete multiple geoStates' })
-  async deleteGeoStates(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+  async deleteGeoStates(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
     const { tx } = context.state
 
     await tx.getRepository(GeoState).delete({

package/server/service/geo-state/geo-state-query.ts

@@ -1,7 +1,8 @@
-import { User } from '@things-factory/auth-base'
-import { convertListParams, ListParam } from '@things-factory/shell'
 import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
 import { GeoCountry } from '../geo-country/geo-country'
 import { GeoState } from './geo-state'
 import { GeoStateList } from './geo-state-type'
@@ -9,14 +10,14 @@ import { GeoStateList } from './geo-state-type'
 @Resolver(GeoState)
 export class GeoStateQuery {
   @Query(returns => GeoState, { description: 'To fetch a GeoState' })
-  async geoState(@Arg('id') id: string, @Ctx() context: any): Promise<GeoState> {
+  async geoState(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<GeoState> {
     return await getRepository(GeoState).findOne({
       where: { id }
     })
   }
 
   @Query(returns => GeoStateList, { description: 'To fetch multiple GeoStates' })
-  async geoStates(@Args() params: ListParam, @Ctx() context: any): Promise<GeoStateList> {
+  async geoStates(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<GeoStateList> {
     const convertedParams = convertListParams(params)
     const [items, total] = await getRepository(GeoState).findAndCount(convertedParams)
 
@@ -25,16 +26,16 @@ export class GeoStateQuery {
 
   @FieldResolver(type => GeoCountry)
   async geoCountry(@Root() geoState: GeoState): Promise<GeoCountry> {
-    return await getRepository(GeoCountry).findOne(geoState.geoCountryId)
+    return await getRepository(GeoCountry).findOneBy({ id: geoState.geoCountryId })
   }
 
   @FieldResolver(type => User)
   async updater(@Root() geoState: GeoState): Promise<User> {
-    return await getRepository(User).findOne(geoState.updaterId)
+    return await getRepository(User).findOneBy({ id: geoState.updaterId })
   }
 
   @FieldResolver(type => User)
   async creator(@Root() geoState: GeoState): Promise<User> {
-    return await getRepository(User).findOne(geoState.creatorId)
+    return await getRepository(User).findOneBy({ id: geoState.creatorId })
   }
 }