@things-factory/integration-base 6.2.34 → 6.2.37

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

@@ -0,0 +1,166 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { ScalarObject } from '@things-factory/shell'
+import { StateRegister } from './state-register'
+import { NewStateRegister, StateRegisterPatch } from './state-register-type'
+
+@Resolver(StateRegister)
+export class StateRegisterMutation {
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => StateRegister, { description: 'To create new StateRegister' })
+  async createStateRegister(
+    @Arg('stateRegister') stateRegister: NewStateRegister,
+    @Ctx() context: ResolverContext
+  ): Promise<StateRegister> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(StateRegister).save({
+      ...stateRegister,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => StateRegister, { description: 'To modify StateRegister information' })
+  async updateStateRegister(
+    @Arg('id') id: string,
+    @Arg('patch') patch: StateRegisterPatch,
+    @Ctx() context: ResolverContext
+  ): Promise<StateRegister> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(StateRegister)
+    const stateRegister = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    return await repository.save({
+      ...stateRegister,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => [StateRegister], { description: "To modify multiple StateRegisters' information" })
+  async updateMultipleStateRegister(
+    @Arg('patches', type => [StateRegisterPatch]) patches: StateRegisterPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<StateRegister[]> {
+    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 stateRegisterRepo = tx.getRepository(StateRegister)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await stateRegisterRepo.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 stateRegister = await stateRegisterRepo.findOneBy({ id: updateRecord.id })
+
+        const result = await stateRegisterRepo.save({
+          ...stateRegister,
+          ...updateRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => StateRegister, { description: 'To update state of StateRegister by name' })
+  async updateStateRegisterByName(
+    @Arg('name') name: string,
+    @Arg('state', type => ScalarObject) state: any,
+    @Ctx() context: ResolverContext
+  ): Promise<StateRegister> {
+    const { domain, user = null, tx } = context.state
+
+    const repository = tx.getRepository(StateRegister)
+    const stateRegister = await repository.findOne({
+      where: { domain: { id: domain?.id }, name }
+    })
+
+    return await repository.save({
+      ...stateRegister,
+      state,
+      writer: user,
+      wroteAt: new Date()
+    })
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete StateRegister' })
+  async deleteStateRegister(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(StateRegister).delete({ domain: { id: domain.id }, id })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To delete multiple StateRegisters' })
+  async deleteStateRegisters(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(StateRegister).delete({
+      domain: { id: domain.id },
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Directive('@privilege(category: "state-register", privilege: "mutation", domainOwnerGranted: true)')
+  @Mutation(returns => Boolean, { description: 'To import multiple StateRegisters' })
+  async importStateRegisters(
+    @Arg('stateRegisters', type => [StateRegisterPatch]) stateRegisters: StateRegisterPatch[],
+    @Ctx() context: ResolverContext
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await Promise.all(
+      stateRegisters.map(async (stateRegister: StateRegisterPatch) => {
+        const createdStateRegister: StateRegister = await tx
+          .getRepository(StateRegister)
+          .save({ domain, ...stateRegister })
+      })
+    )
+
+    return true
+  }
+}

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

@@ -0,0 +1,77 @@
+import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
+import { Domain, getQueryBuilderFromListParams, getRepository, ListParam, ScalarObject } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+import { StateRegister } from './state-register'
+import { StateRegisterList } from './state-register-type'
+
+@Resolver(StateRegister)
+export class StateRegisterQuery {
+  @Directive('@privilege(category: "state-register", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => StateRegister!, { nullable: true, description: 'To fetch a StateRegister' })
+  async stateRegister(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<StateRegister> {
+    const { domain } = context.state
+
+    return await getRepository(StateRegister).findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+  }
+
+  @Directive('@privilege(category: "state-register", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => StateRegister!, { nullable: true, description: 'To fetch a StateRegister by name' })
+  async stateRegisterByName(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<StateRegister> {
+    const { domain } = context.state
+
+    return await getRepository(StateRegister).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  }
+
+  @Directive('@privilege(category: "state-register", privilege: "query", domainOwnerGranted: true)')
+  @Query(returns => StateRegisterList, { description: 'To fetch multiple StateRegisters' })
+  async stateRegisters(@Args() params: ListParam, @Ctx() context: ResolverContext): Promise<StateRegisterList> {
+    const { domain } = context.state
+
+    const queryBuilder = getQueryBuilderFromListParams({
+      domain,
+      params,
+      repository: await getRepository(StateRegister),
+      searchables: ['name', 'description']
+    })
+
+    const [items, total] = await queryBuilder.getManyAndCount()
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => ScalarObject)
+  async state(@Root() stateRegister: StateRegister): Promise<any> {
+    const { state, wroteAt, ttl } = stateRegister
+
+    if (!isNaN(ttl) && Number(ttl) > 0) {
+      const expired = (wroteAt?.getTime() || 0) + Number(ttl) * 1000 < Date.now()
+      return expired ? null : state
+    } else {
+      return state
+    }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() stateRegister: StateRegister): Promise<Domain> {
+    return stateRegister.domainId && (await getRepository(Domain).findOneBy({ id: stateRegister.domainId }))
+  }
+
+  @FieldResolver(type => User)
+  async writer(@Root() stateRegister: StateRegister): Promise<User> {
+    return stateRegister.writerId && (await getRepository(User).findOneBy({ id: stateRegister.writerId }))
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() stateRegister: StateRegister): Promise<User> {
+    return stateRegister.updaterId && (await getRepository(User).findOneBy({ id: stateRegister.updaterId }))
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() stateRegister: StateRegister): Promise<User> {
+    return stateRegister.creatorId && (await getRepository(User).findOneBy({ id: stateRegister.creatorId }))
+  }
+}

package/server/service/state-register/state-register-type.ts

@@ -0,0 +1,64 @@
+import type { FileUpload } from 'graphql-upload/GraphQLUpload.js'
+import GraphQLUpload from 'graphql-upload/GraphQLUpload.js'
+import { ObjectType, Field, InputType, Int, ID, registerEnumType } from 'type-graphql'
+
+import { ObjectRef, ScalarObject } from '@things-factory/shell'
+
+import { StateRegister } from './state-register'
+
+@InputType()
+export class NewStateRegister {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  state?: any
+
+  @Field(type => Int, { nullable: true })
+  ttl?: number
+
+  @Field({ nullable: true })
+  refBy?: string
+}
+
+@InputType()
+export class StateRegisterPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  type?: string
+
+  @Field(type => ScalarObject, { nullable: true })
+  state?: any
+
+  @Field(type => Int, { nullable: true })
+  ttl?: number
+
+  @Field({ nullable: true })
+  refBy?: string
+
+  @Field({ nullable: true })
+  cuFlag?: string
+}
+
+@ObjectType()
+export class StateRegisterList {
+  @Field(type => [StateRegister])
+  items: StateRegister[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/state-register/state-register.ts

@@ -0,0 +1,91 @@
+import {
+  CreateDateColumn,
+  UpdateDateColumn,
+  DeleteDateColumn,
+  Entity,
+  Index,
+  Column,
+  RelationId,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  VersionColumn
+} from 'typeorm'
+import { ObjectType, Field, Int, ID, registerEnumType } from 'type-graphql'
+
+import { Domain, ScalarObject } from '@things-factory/shell'
+import { User } from '@things-factory/auth-base'
+
+@Entity()
+@Index('ix_state_register_0', (stateRegister: StateRegister) => [stateRegister.domain, stateRegister.name], {
+  unique: true
+})
+@ObjectType({ description: 'Entity for StateRegister' })
+export class StateRegister {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((stateRegister: StateRegister) => stateRegister.domain)
+  domainId?: string
+
+  @Column()
+  @Field({ nullable: true })
+  name?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  type?: string
+
+  @Column('simple-json', { nullable: true, default: null })
+  @Field(type => ScalarObject, { nullable: true })
+  state?: any
+
+  @Column({ nullable: true, default: null })
+  @Field(type => Int, { nullable: true })
+  ttl?: number
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  refBy?: string
+
+  @Column({ nullable: true })
+  @Field({ nullable: true })
+  wroteAt?: Date
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  writer?: User
+
+  @RelationId((stateRegister: StateRegister) => stateRegister.writer)
+  writerId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  creator?: User
+
+  @RelationId((stateRegister: StateRegister) => stateRegister.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, { nullable: true })
+  @Field(type => User, { nullable: true })
+  updater?: User
+
+  @RelationId((stateRegister: StateRegister) => stateRegister.updater)
+  updaterId?: string
+}