@things-factory/rack-base 5.0.8 → 6.0.0-alpha.0

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@things-factory/rack-base",
-  "version": "5.0.8",
+  "version": "6.0.0-alpha.0",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
   "license": "MIT",
-  "author": "heartyoh",
+  "author": "heartyoh <heartyoh@hatiolab.com>",
   "description": "rack-base",
   "publishConfig": {
     "access": "public",
@@ -17,18 +17,20 @@
     "directory": "packages/rack-base"
   },
   "scripts": {
-    "build": "tsc --p tsconfig.json",
-    "build:server": "npm run clean:server && tsc",
-    "clean:server": "rm -rf dist-server",
-    "clean": "npm run clean:server",
+    "build": "npm run build:server && npm run build:client",
+    "build:client": "npx tsc --p ./client/tsconfig.json",
+    "build:server": "npx tsc --p ./server/tsconfig.json",
+    "clean:client": "npx rimraf dist-client",
+    "clean:server": "npx rimraf dist-server",
+    "clean": "npm run clean:server && npm run clean:client",
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^5.0.7",
-    "@things-factory/shell": "^5.0.7"
+    "@things-factory/auth-base": "^6.0.0-alpha.0",
+    "@things-factory/shell": "^6.0.0-alpha.0"
   },
   "devDependencies": {
-    "@things-factory/builder": "^5.0.8"
+    "@things-factory/builder": "^6.0.0-alpha.0"
   },
-  "gitHead": "de14539186ad35c0bd1379b8ae4dccda7b13256e"
+  "gitHead": "e5b9823ab3ebc5d6ae5bcb4b5aa60c1306e4dd7e"
 }

package/server/index.ts

@@ -1,6 +1 @@
-export * from './entities'
-export * from './migrations'
-export * from './graphql'
-export * from './middlewares'
-
-import './routes'
+export * from './service'

package/server/routes.ts

@@ -1,5 +1,3 @@
-const debug = require('debug')('things-factory:rack-base:routes')
-
 process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
   /*
    * can add global public routes to application (auth not required, tenancy not required)

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

@@ -0,0 +1,133 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { Cell } from './cell'
+import { CellPatch, NewCell } from './cell-type'
+
+@Resolver(Cell)
+export class CellMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Cell, { description: 'To create new Cell' })
+  async createCell(@Arg('cell') cell: NewCell, @Ctx() context: ResolverContext): Promise<Cell> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Cell).save({
+      ...cell,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Cell, { description: 'To modify Cell information' })
+  async updateCell(
+    @Arg('id') id: string,
+    @Arg('patch') patch: CellPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Cell> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Cell)
+    const cell = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...cell,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Cell], { description: "To modify multiple Cells' information" })
+  async updateMultipleCell(
+    @Arg('patches', type => [CellPatch]) patches: CellPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Cell[]> {
+    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 cellRepo = tx.getRepository(Cell)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await cellRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const cell = await cellRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await cellRepo.save({
+          ...cell,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Cell' })
+  async deleteCell(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Cell).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Cells' })
+  async deleteCells(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Cell).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple Cells' })
+  async importCells(
+    @Arg('cells', type => [CellPatch]) cells: CellPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      cells.map(async (cell: CellPatch) => {
+        const createdCell: Cell = await tx.getRepository(Cell).save({ domain, ...cell })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,50 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Cell } from './cell'
+import { CellList } from './cell-type'
+
+@Resolver(Cell)
+export class CellQuery {
+  @Query(returns => Cell!, { nullable: true, description: 'To fetch a Cell' })
+  async cell(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Cell> {
+    const { domain } = context.state
+
+    return await getRepository(Cell).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => CellList, { description: 'To fetch multiple Cells' })
+  async cells(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<CellList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Cell),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() cell: Cell): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: cell.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() cell: Cell): Promise<User> {
+    return await getRepository(User).findOneBy({ id: cell.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() cell: Cell): Promise<User> {
+    return await getRepository(User).findOneBy({ id: cell.creatorId })
+  }
+}

package/server/service/cell/cell-type.ts

@@ -0,0 +1,96 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Cell } from './cell'
+
+@InputType()
+export class NewCell {
+  @Field({ nullable: true })
+  stationCd: string
+
+  @Field()
+  equipCd: string
+
+  @Field()
+  cellCd: string
+
+  @Field()
+  indCd: string
+
+  @Field()
+  channelNo: string
+
+  @Field()
+  panNo: string
+
+  @Field({ nullable: true })
+  equipZone?: string
+
+  @Field({ nullable: true })
+  sideCd?: string
+
+  @Field({ nullable: true })
+  cellSeq?: number
+
+  @Field({ nullable: true })
+  printerCd?: string
+
+  @Field({ nullable: true })
+  activeFlag?: boolean
+
+  @Field({ nullable: true })
+  status?: string
+}
+
+@InputType()
+export class CellPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  stationCd?: string
+
+  @Field({ nullable: true })
+  equipCd?: string
+
+  @Field({ nullable: true })
+  cellCd?: string
+
+  @Field({ nullable: true })
+  indCd?: string
+
+  @Field({ nullable: true })
+  channelNo?: string
+
+  @Field({ nullable: true })
+  panNo?: string
+
+  @Field({ nullable: true })
+  equipZone?: string
+
+  @Field({ nullable: true })
+  sideCd?: string
+
+  @Field({ nullable: true })
+  cellSeq?: number
+
+  @Field({ nullable: true })
+  printerCd?: string
+
+  @Field({ nullable: true })
+  activeFlag?: boolean
+
+  @Field({ nullable: true })
+  status?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class CellList {
+  @Field(type => [Cell])
+  items: Cell[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/cell/cell.ts

@@ -0,0 +1,112 @@
+import { Field, ID, ObjectType } from 'type-graphql'
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  RelationId,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index('ix_cell_0', (cell: Cell) => [cell.domain, cell.cellCd], { unique: true })
+@ObjectType({ description: 'Entity for Cell' })
+export class Cell {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((cell: Cell) => cell.domain)
+  domainId?: string
+
+  @Column({ nullable: true, length: 30 })
+  @Field({ nullable: true })
+  stationCd: string
+
+  @Column({ length: 30 })
+  @Field()
+  equipCd: string
+
+  @Column({ length: 30 })
+  @Field()
+  cellCd: string
+
+  @Column({ length: 30 })
+  @Field()
+  indCd: string
+
+  @Column({ length: 40 })
+  @Field()
+  channelNo: string
+
+  @Column({ length: 40 })
+  @Field()
+  panNo: string
+
+  @Column({ nullable: true, length: 30 })
+  @Field({ nullable: true })
+  equipZone?: string
+
+  @Column({ nullable: true, length: 30 })
+  @Field({ nullable: true })
+  sideCd?: string
+
+  @Column({ nullable: true, width: 10 })
+  @Field({ nullable: true })
+  cellSeq?: number
+
+  @Column({ nullable: true, length: 30 })
+  @Field({ nullable: true })
+  printerCd?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  activeFlag?: boolean
+
+  @Column({ nullable: true, width: 10 })
+  @Field({ nullable: true })
+  status?: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  params?: string
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((cell: Cell) => cell.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((cell: Cell) => cell.creator)
+  updaterId?: string
+}

package/server/service/cell/index.ts

@@ -0,0 +1,6 @@
+import { Cell } from './cell'
+import { CellQuery } from './cell-query'
+import { CellMutation } from './cell-mutation'
+
+export const entities = [Cell]
+export const resolvers = [CellQuery, CellMutation]

package/server/service/index.ts

@@ -0,0 +1,22 @@
+/* EXPORT ENTITY TYPES */
+export * from './rack/rack'
+export * from './cell/cell'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as RackEntities, resolvers as RackResolvers } from './rack'
+import { entities as CellEntities, resolvers as CellResolvers } from './cell'
+
+export const entities = [  
+  /* ENTITIES */
+	...RackEntities,
+	...CellEntities,
+] 
+
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...RackResolvers,
+		...CellResolvers,
+  ] 
+}

package/server/service/rack/index.ts

@@ -0,0 +1,6 @@
+import { Rack } from './rack'
+import { RackQuery } from './rack-query'
+import { RackMutation } from './rack-mutation'
+
+export const entities = [Rack]
+export const resolvers = [RackQuery, RackMutation]

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

@@ -0,0 +1,133 @@
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { deleteAttachmentsByRef } from '@things-factory/attachment-base'
+
+import { Rack } from './rack'
+import { NewRack, RackPatch } from './rack-type'
+
+@Resolver(Rack)
+export class RackMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Rack, { description: 'To create new Rack' })
+  async createRack(@Arg('rack') rack: NewRack, @Ctx() context: ResolverContext): Promise<Rack> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Rack).save({
+      ...rack,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Rack, { description: 'To modify Rack information' })
+  async updateRack(
+    @Arg('id') id: string,
+    @Arg('patch') patch: RackPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<Rack> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Rack)
+    const rack = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...rack,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Rack], { description: "To modify multiple Racks' information" })
+  async updateMultipleRack(
+    @Arg('patches', type => [RackPatch]) patches: RackPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<Rack[]> {
+    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 rackRepo = tx.getRepository(Rack)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await rackRepo.save({
+          ...newRecord,
+          domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const updateRecord = _updateRecords[i]
+        const rack = await rackRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await rackRepo.save({
+          ...rack,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Rack' })
+  async deleteRack(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Rack).delete({ domain: { id: domain.id }, id })
+    await deleteAttachmentsByRef(null, { refBys: [id] }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple Racks' })
+  async deleteRacks(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Rack).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    await deleteAttachmentsByRef(null, { refBys: ids }, context)
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To import multiple Racks' })
+  async importRacks(
+    @Arg('racks', type => [RackPatch]) racks: RackPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      racks.map(async (rack: RackPatch) => {
+        const createdRack: Rack = await tx.getRepository(Rack).save({ domain, ...rack })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,64 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+
+import { Attachment } from '@things-factory/attachment-base'
+import { User } from '@things-factory/auth-base'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Rack } from './rack'
+import { RackList } from './rack-type'
+
+@Resolver(Rack)
+export class RackQuery {
+  @Query(returns => Rack!, { nullable: true, description: 'To fetch a Rack' })
+  async rack(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<Rack> {
+    const { domain } = context.state
+
+    return await getRepository(Rack).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Query(returns => RackList, { description: 'To fetch multiple Racks' })
+  async racks(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<RackList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(Rack),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => String)
+  async thumbnail(@Root() rack: Rack): Promise<string | undefined> {
+    const attachment: Attachment = await getRepository(Attachment).findOne({
+      where: {
+        domain: { id: rack.domainId },
+        refType: Rack.name,
+        refBy: rack.id
+      }
+    })
+
+    return attachment?.fullpath
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() rack: Rack): Promise<Domain> {
+    return await getRepository(Domain).findOneBy({ id: rack.domainId })
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() rack: Rack): Promise<User> {
+    return await getRepository(User).findOneBy({ id: rack.updaterId })
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() rack: Rack): Promise<User> {
+    return await getRepository(User).findOneBy({ id: rack.creatorId })
+  }
+}