@things-factory/geography 8.0.0-beta.1 → 8.0.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/geography",
-  "version": "8.0.0-beta.1",
+  "version": "8.0.0-beta.4",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,8 +24,8 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.1",
-    "@things-factory/shell": "^8.0.0-beta.1"
+    "@things-factory/auth-base": "^8.0.0-beta.4",
+    "@things-factory/shell": "^8.0.0-beta.4"
   },
-  "gitHead": "36c494e587640c1490318ef7b95adab02606e0c2"
+  "gitHead": "d83d12ed4ba07177dff1dac26e37be347d156b43"
 }

package/server/index.ts

@@ -1,5 +0,0 @@
-export * from './migrations'
-export * from './middlewares'
-export * from './service'
-
-import './routes'

package/server/middlewares/index.ts

@@ -1,3 +0,0 @@
-export function initMiddlewares(app) {
-  /* can add middlewares into app */
-}

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/routes.ts

@@ -1,26 +0,0 @@
-process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
-  /*
-   * can add global public routes to application (auth not required, tenancy not required)
-   *
-   * ex) routes.get('/path', async(context, next) => {})
-   * ex) routes.post('/path', async(context, next) => {})
-   */
-})
-
-process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
-  /*
-   * can add global private routes to application (auth required, tenancy not required)
-   */
-})
-
-process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
-  /*
-   * can add domain public routes to application (auth not required, tenancy required)
-   */
-})
-
-process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
-  /*
-   * can add domain private routes to application (auth required, tenancy required)
-   */
-})

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

@@ -1,107 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { GeoArea } from './geo-area'
-import { GeoAreaPatch, NewGeoArea } from './geo-area-type'
-
-@Resolver(GeoArea)
-export class GeoAreaMutation {
-  @Directive('@transaction')
-  @Mutation(returns => GeoArea, { description: 'To create new GeoArea' })
-  async createGeoArea(@Arg('geoArea') geoArea: NewGeoArea, @Ctx() context: ResolverContext): Promise<GeoArea> {
-    const { user, tx } = context.state
-
-    return await tx.getRepository(GeoArea).save({
-      ...geoArea,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => GeoArea, { description: 'To modify GeoArea information' })
-  async updateGeoArea(
-    @Arg('id') id: string,
-    @Arg('patch') patch: GeoAreaPatch,
-    @Ctx() context: ResolverContext
-  ): Promise<GeoArea> {
-    const { user, tx } = context.state
-
-    const repository = tx.getRepository(GeoArea)
-    const geoArea = await repository.findOne({
-      where: { id }
-    })
-
-    return await repository.save({
-      ...geoArea,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [GeoArea], { description: "To modify multiple GeoAreas' information" })
-  async updateMultipleGeoArea(
-    @Arg('patches', type => [GeoAreaPatch]) patches: GeoAreaPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<GeoArea[]> {
-    const { 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 geoAreaRepo = tx.getRepository(GeoArea)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await geoAreaRepo.save({
-          ...newRecord,
-          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 geoArea = await geoAreaRepo.findOneBy({ id: newRecord.id })
-
-        const result = await geoAreaRepo.save({
-          ...geoArea,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete GeoArea' })
-  async deleteGeoArea(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(GeoArea).delete({ id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple geoAreas' })
-  async deleteGeoAreas(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(GeoArea).delete({
-      id: In(ids)
-    })
-
-    return true
-  }
-}

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

@@ -1,74 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-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'
-
-@Resolver(GeoArea)
-export class GeoAreaQuery {
-  @Query(returns => GeoArea, { description: 'To fetch a 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(type => ListParam) 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).findOneBy({ id: geoArea.geoCityId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() geoArea: GeoArea): Promise<User> {
-    return await getRepository(User).findOneBy({ id: geoArea.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() geoArea: GeoArea): Promise<User> {
-    return await getRepository(User).findOneBy({ id: geoArea.creatorId })
-  }
-}

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

@@ -1,71 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-import { GeoArea } from './geo-area'
-
-@InputType()
-export class NewGeoArea {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  countryCode?: string
-
-  @Field({ nullable: true })
-  cityName?: string
-
-  @Field({ nullable: true })
-  stateName?: string
-
-  @Field({ nullable: true })
-  postalCode?: string
-
-  @Field({ nullable: true })
-  latitude?: string
-
-  @Field({ nullable: true })
-  longitude?: string
-}
-
-@InputType()
-export class GeoAreaPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  countryCode?: string
-
-  @Field({ nullable: true })
-  cityName?: string
-
-  @Field({ nullable: true })
-  stateName?: string
-
-  @Field({ nullable: true })
-  postalCode?: string
-
-  @Field({ nullable: true })
-  latitude?: string
-
-  @Field({ nullable: true })
-  longitude?: string
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class GeoAreaList {
-  @Field(type => [GeoArea])
-  items: GeoArea[]
-
-  @Field(type => Int)
-  total: number
-}

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

@@ -1,85 +0,0 @@
-import { User } from '@things-factory/auth-base'
-import { Field, ID, ObjectType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-import { GeoCity } from '../geo-city/geo-city'
-
-@Entity()
-@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')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => GeoCity)
-  @Field({ nullable: true })
-  geoCity?: GeoCity
-
-  @RelationId((geoArea: GeoArea) => geoArea.geoCity)
-  geoCityId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  countryCode?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  cityName?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  stateName?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  postalCode?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  latitude?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  longitude?: 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((geoArea: GeoArea) => geoArea.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((geoArea: GeoArea) => geoArea.updater)
-  updaterId?: string
-}

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

@@ -1,6 +0,0 @@
-import { GeoArea } from './geo-area'
-import { GeoAreaQuery } from './geo-area-query'
-import { GeoAreaMutation } from './geo-area-mutation'
-
-export const entities = [GeoArea]
-export const resolvers = [GeoAreaQuery, GeoAreaMutation]

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

@@ -1,110 +0,0 @@
-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'
-
-@Resolver(GeoCity)
-export class GeoCityMutation {
-  @Directive('@transaction')
-  @Mutation(returns => GeoCity, { description: 'To create new GeoCity' })
-  async createGeoCity(@Arg('geoCity') geoCity: NewGeoCity, @Ctx() context: ResolverContext): Promise<GeoCity> {
-    const { user, tx } = context.state
-
-    return await tx.getRepository(GeoCity).save({
-      ...geoCity,
-      creator: user,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => GeoCity, { description: 'To modify GeoCity information' })
-  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)
-    const geoCity = await repository.findOne({
-      where: { id }
-    })
-
-    return await repository.save({
-      ...geoCity,
-      ...patch,
-      updater: user
-    })
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => [GeoCity], { description: "To modify multiple GeoCities' information" })
-  async updateMultipleGeoCity(
-    @Arg('patches', type => [GeoCityPatch]) patches: GeoCityPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<GeoCity[]> {
-    const { 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 geoCityRepo = tx.getRepository(GeoCity)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await geoCityRepo.save({
-          ...newRecord,
-          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 geoCity = await geoCityRepo.findOneBy({ id: newRecord.id })
-
-        const result = await geoCityRepo.save({
-          ...geoCity,
-          ...newRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete GeoCity' })
-  async deleteGeoCity(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(GeoCity).delete({ id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple geoCitys' })
-  async deleteGeoCities(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { tx } = context.state
-
-    await tx.getRepository(GeoCity).delete({
-      id: In(ids)
-    })
-
-    return true
-  }
-}

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

@@ -1,47 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-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'
-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: ResolverContext): Promise<GeoCity> {
-    return await getRepository(GeoCity).findOne({
-      where: { id }
-    })
-  }
-
-  @Query(returns => GeoCityList, { description: 'To fetch multiple GeoCities' })
-  async geoCities(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<GeoCityList> {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(GeoCity).findAndCount(convertedParams)
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => GeoCountry)
-  async geoCountry(@Root() geoCity: GeoCity): Promise<GeoCountry> {
-    return await getRepository(GeoCountry).findOneBy({ id: geoCity.geoCountryId })
-  }
-
-  @FieldResolver(type => GeoState)
-  async geoState(@Root() geoCity: GeoCity): Promise<GeoState> {
-    return await getRepository(GeoState).findOneBy({ id: geoCity.geoStateId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() geoCity: GeoCity): Promise<User> {
-    return await getRepository(User).findOneBy({ id: geoCity.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() geoCity: GeoCity): Promise<User> {
-    return await getRepository(User).findOneBy({ id: geoCity.creatorId })
-  }
-}

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

@@ -1,47 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-import { GeoCity } from './geo-city'
-
-@InputType()
-export class NewGeoCity {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  latitude?: string
-
-  @Field({ nullable: true })
-  longitude?: string
-}
-
-@InputType()
-export class GeoCityPatch {
-  @Field(type => ID, { nullable: true })
-  id?: string
-
-  @Field({ nullable: true })
-  name?: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field({ nullable: true })
-  latitude?: string
-
-  @Field({ nullable: true })
-  longitude?: string
-
-  @Field()
-  cuFlag: string
-}
-
-@ObjectType()
-export class GeoCityList {
-  @Field(type => [GeoCity])
-  items: GeoCity[]
-
-  @Field(type => Int)
-  total: number
-}