@things-factory/integration-base 8.0.0-beta.1 → 8.0.0-beta.2

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

@@ -1,166 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<StateRegisterList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(StateRegister),
-      searchables: ['name', 'description', 'group']
-    })
-
-    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

@@ -1,80 +0,0 @@
-import { ObjectType, Field, InputType, Int, ID } from 'type-graphql'
-
-import { ScalarObject } from '@things-factory/shell'
-
-import { StateRegister } from './state-register'
-
-@InputType()
-export class NewStateRegister {
-  @Field({ description: 'Name of the state register' })
-  name: string
-
-  @Field({ nullable: true, description: 'Description of the state register' })
-  description?: string
-
-  @Field({ nullable: true, description: 'Group name for the state register' })
-  group?: string
-
-  @Field({ nullable: true, description: 'Type of the state' })
-  type?: string
-
-  @Field({ nullable: true, description: 'Number of decimal places if the state is a number type' })
-  place?: string
-
-  @Field({ nullable: true, description: 'Unit of the state value' })
-  unit?: string
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Current state value' })
-  state?: any
-
-  @Field(type => Int, { nullable: true, description: 'Time to live for the state value in seconds' })
-  ttl?: number
-
-  @Field({ nullable: true, description: 'Reference to an external entity or data, used as a flexible foreign key' })
-  refBy?: string
-}
-
-@InputType()
-export class StateRegisterPatch {
-  @Field(type => ID, { nullable: true, description: 'ID of the state register' })
-  id?: string
-
-  @Field({ nullable: true, description: 'Name of the state register' })
-  name?: string
-
-  @Field({ nullable: true, description: 'Description of the state register' })
-  description?: string
-
-  @Field({ nullable: true, description: 'Group name for the state register' })
-  group?: string
-
-  @Field({ nullable: true, description: 'Type of the state' })
-  type?: string
-
-  @Field({ nullable: true, description: 'Number of decimal places if the state is a number type' })
-  place?: string
-
-  @Field({ nullable: true, description: 'Unit of the state value' })
-  unit?: string
-
-  @Field(type => ScalarObject, { nullable: true, description: 'Current state value' })
-  state?: any
-
-  @Field(type => Int, { nullable: true, description: 'Time to live for the state value in seconds' })
-  ttl?: number
-
-  @Field({ nullable: true, description: 'Reference to an external entity or data, used as a flexible foreign key' })
-  refBy?: string
-
-  @Field({ nullable: true, description: 'Flag indicating create/update operations' })
-  cuFlag?: string
-}
-
-@ObjectType()
-export class StateRegisterList {
-  @Field(type => [StateRegister], { description: 'List of state registers' })
-  items: StateRegister[]
-
-  @Field(type => Int, { description: 'Total number of state registers' })
-  total: number
-}

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

@@ -1,113 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn
-} from 'typeorm'
-import { ObjectType, Field, Int, ID } 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
-})
-@Index(
-  'ix_state_register_1',
-  (stateRegister: StateRegister) => [stateRegister.domain, stateRegister.group, stateRegister.name],
-  {
-    unique: true,
-    where: '"group" IS NOT NULL'
-  }
-)
-@ObjectType({ description: 'Entity for StateRegister' })
-export class StateRegister {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain, { description: 'Associated domain for the state register' })
-  domain?: Domain
-
-  @RelationId((stateRegister: StateRegister) => stateRegister.domain)
-  @Field({ description: 'ID of the associated domain' })
-  domainId?: string
-
-  @Column()
-  @Field({ nullable: true, description: 'Name of the state register' })
-  name?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Description of the state register' })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Group name for the state register' })
-  group?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Type of the state' })
-  type?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Number of decimal places if the state is a number type' })
-  place?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Unit of the state value' })
-  unit?: string
-
-  @Column('simple-json', { nullable: true, default: null })
-  @Field(type => ScalarObject, { nullable: true, description: 'Current state value' })
-  state?: any
-
-  @Column({ nullable: true, default: null })
-  @Field(type => Int, { nullable: true, description: 'Time to live for the state value in seconds' })
-  ttl?: number
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Reference to an external entity or data, used as a flexible foreign key' })
-  refBy?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Time when the state was recorded' })
-  wroteAt?: Date
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'Creation time of the state register' })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'Last update time of the state register' })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who wrote the state' })
-  writer?: User
-
-  @RelationId((stateRegister: StateRegister) => stateRegister.writer)
-  @Field({ nullable: true, description: 'ID of the user who wrote the state' })
-  writerId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who created the state register' })
-  creator?: User
-
-  @RelationId((stateRegister: StateRegister) => stateRegister.creator)
-  @Field({ nullable: true, description: 'ID of the user who created the state register' })
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who last updated the state register' })
-  updater?: User
-
-  @RelationId((stateRegister: StateRegister) => stateRegister.updater)
-  @Field({ nullable: true, description: 'ID of the user who last updated the state register' })
-  updaterId?: string
-}

package/server/service/step/index.ts

@@ -1,6 +0,0 @@
-import { Step } from './step-type'
-import { StepQuery } from './step-query'
-import { StepMutation } from './step-mutation'
-
-export const entities = [Step]
-export const resolvers = [StepQuery, StepMutation]

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

@@ -1,52 +0,0 @@
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { In } from 'typeorm'
-
-import { Scenario } from '../scenario/scenario'
-import { Step, StepPatch } from './step-type'
-
-@Resolver(Step)
-export class StepMutation {
-  @Directive('@transaction')
-  @Mutation(returns => [Step], { description: "To modify multiple steps' in a scenario" })
-  async updateMultipleStep(
-    @Arg('scenarioId') scenarioId: string,
-    @Arg('patches', type => [StepPatch]) patches: StepPatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<Step[]> {
-    const { domain, user, tx } = context.state
-
-    let results = []
-    const stepRepo = tx.getRepository(Step)
-    const scenario = await tx.getRepository(Scenario).findOneBy({ id: scenarioId })
-
-    await stepRepo.delete({ domain: { id: domain.id }, scenario: { id: scenarioId } })
-
-    for (let i = 0; i < patches.length; i++) {
-      const result = await stepRepo.save({
-        ...patches[i],
-        sequence: i,
-        scenario,
-        domain,
-        creator: user,
-        updater: user
-      })
-
-      results.push({ ...result, cuFlag: '+' })
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple steps' })
-  async deleteSteps(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Step).delete({
-      domain: { id: domain.id },
-      id: In(ids.filter(Boolean))
-    })
-
-    return true
-  }
-}

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

@@ -1,55 +0,0 @@
-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 { Scenario } from '../scenario/scenario'
-import { Step, StepList } from './step-type'
-
-@Resolver(Step)
-export class StepQuery {
-  @Query(returns => Step, { description: 'To fetch a step' })
-  async step(@Arg('name') name: string, @Ctx() context: ResolverContext): Promise<Step> {
-    const { domain } = context.state
-
-    return await getRepository(Step).findOne({
-      where: { domain: { id: domain.id }, name }
-    })
-  }
-
-  @Query(returns => StepList, { description: 'To fetch multiple steps' })
-  async steps(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<StepList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      repository: getRepository(Step),
-      params,
-      domain,
-      searchables: ['name', 'description']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @FieldResolver(type => Scenario)
-  async scenario(@Root() step: Step) {
-    return await getRepository(Scenario).findOneBy({ id: step.scenarioId })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() step: Step) {
-    return await getRepository(Domain).findOneBy({ id: step.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() step: Step): Promise<User> {
-    return await getRepository(User).findOneBy({ id: step.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() step: Step): Promise<User> {
-    return await getRepository(User).findOneBy({ id: step.creatorId })
-  }
-}