@things-factory/kpi 9.2.5 → 10.0.0-beta.10

package/server/service/kpi-org-scope/kpi-org-scope-mutation.ts

@@ -1,173 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-
-import { KpiOrgScope } from './kpi-org-scope'
-import { NewKpiOrgScope, KpiOrgScopePatch } from './kpi-org-scope-type'
-
-@Resolver(KpiOrgScope)
-export class KpiOrgScopeMutation {
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => KpiOrgScope, { description: 'Create a new KPI org-scope mapping with the provided details.' })
-  async createKpiOrgScope(
-    @Arg('kpiOrgScope', { description: 'Input object containing details for the new org-scope mapping.' })
-    kpiOrgScope: NewKpiOrgScope,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiOrgScope> {
-    const { domain, user, tx } = context.state
-
-    // Check if org already exists for this domain
-    const existingOrgScope = await getRepository(KpiOrgScope, tx).findOne({
-      where: { domain: { id: domain.id }, org: kpiOrgScope.org }
-    })
-
-    if (existingOrgScope) {
-      throw new Error(`Organization '${kpiOrgScope.org}' already has a scope mapping in this domain`)
-    }
-
-    const entity: Partial<KpiOrgScope> = {
-      ...kpiOrgScope,
-      domain,
-      creator: user,
-      updater: user
-    }
-
-    return await getRepository(KpiOrgScope, tx).save(entity)
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => [KpiOrgScope], {
-    description: 'Update multiple KPI org-scope mappings with the provided patches.'
-  })
-  async updateMultipleKpiOrgScope(
-    @Arg('patches', type => [KpiOrgScopePatch], {
-      description: 'Array of patch objects for updating org-scope mappings.'
-    })
-    patches: KpiOrgScopePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiOrgScope[]> {
-    const { domain, user, tx } = context.state
-
-    const ids = patches.map(patch => patch.id)
-    const existingOrgScopes = await getRepository(KpiOrgScope, tx).find({
-      where: {
-        domain: { id: domain.id },
-        id: In(ids)
-      }
-    })
-
-    if (existingOrgScopes.length !== patches.length) {
-      throw new Error('Some org-scope mappings not found or not accessible')
-    }
-
-    const updatedOrgScopes: KpiOrgScope[] = []
-
-    for (const patch of patches) {
-      const existingOrgScope = existingOrgScopes.find(os => os.id === patch.id)
-      if (!existingOrgScope) continue
-
-      // Check if org is being changed and if new org already exists
-      if (patch.org && patch.org !== existingOrgScope.org) {
-        const duplicateOrgScope = await getRepository(KpiOrgScope, tx).findOne({
-          where: {
-            domain: { id: domain.id },
-            org: patch.org,
-            id: In(ids.filter(id => id !== patch.id))
-          }
-        })
-        if (duplicateOrgScope) {
-          throw new Error(`Organization '${patch.org}' already has a scope mapping in this domain`)
-        }
-      }
-
-      const updatedEntity: Partial<KpiOrgScope> = {
-        ...existingOrgScope,
-        ...patch,
-        updater: user,
-        updatedAt: new Date()
-      }
-
-      const savedOrgScope = await getRepository(KpiOrgScope, tx).save(updatedEntity)
-      updatedOrgScopes.push(savedOrgScope)
-    }
-
-    return updatedOrgScopes
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'Delete KPI org-scope mappings by their IDs.' })
-  async deleteKpiOrgScopes(
-    @Arg('ids', type => [String], { description: 'Array of org-scope mapping IDs to delete.' }) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    const existingOrgScopes = await getRepository(KpiOrgScope, tx).find({
-      where: {
-        domain: { id: domain.id },
-        id: In(ids)
-      }
-    })
-
-    if (existingOrgScopes.length === 0) {
-      throw new Error('No org-scope mappings found to delete')
-    }
-
-    // Soft delete
-    await getRepository(KpiOrgScope, tx).softDelete(existingOrgScopes.map(os => os.id))
-
-    return true
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Directive('@transaction')
-  @Mutation(returns => [KpiOrgScope], { description: 'Bulk create or update KPI org-scope mappings.' })
-  async bulkUpsertKpiOrgScopes(
-    @Arg('orgScopes', type => [NewKpiOrgScope], { description: 'Array of org-scope mapping data for bulk upsert.' })
-    orgScopes: NewKpiOrgScope[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiOrgScope[]> {
-    const { domain, user, tx } = context.state
-
-    const orgs = orgScopes.map(os => os.org)
-    const existingOrgScopes = await getRepository(KpiOrgScope, tx).find({
-      where: {
-        domain: { id: domain.id },
-        org: In(orgs)
-      }
-    })
-
-    const results: KpiOrgScope[] = []
-
-    for (const orgScopeData of orgScopes) {
-      const existing = existingOrgScopes.find(os => os.org === orgScopeData.org)
-
-      if (existing) {
-        // Update existing
-        const updatedEntity: Partial<KpiOrgScope> = {
-          ...existing,
-          ...orgScopeData,
-          updater: user,
-          updatedAt: new Date()
-        }
-        const updated = await getRepository(KpiOrgScope, tx).save(updatedEntity)
-        results.push(updated)
-      } else {
-        // Create new
-        const newEntity: Partial<KpiOrgScope> = {
-          ...orgScopeData,
-          domain,
-          creator: user,
-          updater: user
-        }
-        const saved = await getRepository(KpiOrgScope, tx).save(newEntity)
-        results.push(saved)
-      }
-    }
-
-    return results
-  }
-}

package/server/service/kpi-org-scope/kpi-org-scope-query.ts

@@ -1,127 +0,0 @@
-import { Resolver, Query, FieldResolver, Root, Args, Arg, Ctx, Directive } from 'type-graphql'
-import { Domain, getQueryBuilderFromListParams, getRepository, ListParam } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-import { KpiOrgScope } from './kpi-org-scope'
-import { KpiOrgScopeList } from './kpi-org-scope-type'
-
-@Resolver(KpiOrgScope)
-export class KpiOrgScopeQuery {
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiOrgScope!, {
-    nullable: true,
-    description: 'Fetch a single KPI org-scope mapping by its unique identifier.'
-  })
-  async kpiOrgScope(
-    @Arg('id', { description: 'Unique identifier of the org-scope mapping to fetch.' }) id: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiOrgScope> {
-    const { domain } = context.state
-
-    return await getRepository(KpiOrgScope).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiOrgScopeList, {
-    description: 'Fetch multiple KPI org-scope mappings with filters and pagination'
-  })
-  async kpiOrgScopes(
-    @Args(type => ListParam) params: ListParam,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiOrgScopeList> {
-    const { domain } = context.state
-
-    const queryBuilder = getQueryBuilderFromListParams({
-      domain,
-      params,
-      repository: await getRepository(KpiOrgScope),
-      searchables: ['org', 'scope01', 'scope02', 'scope03', 'scope04', 'scope05']
-    })
-
-    const [items, total] = await queryBuilder.getManyAndCount()
-
-    return { items, total }
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => [String], { description: 'Get distinct values for a specific scope field' })
-  async kpiOrgScopeValues(
-    @Arg('scopeField', { description: 'Scope field to get distinct values from' })
-    scopeField: 'scope01' | 'scope02' | 'scope03' | 'scope04' | 'scope05',
-    @Ctx() context: ResolverContext,
-    @Arg('searchTerm', { nullable: true, description: 'Optional search term to filter values' }) searchTerm?: string
-  ): Promise<string[]> {
-    const { domain } = context.state
-
-    const queryBuilder = getRepository(KpiOrgScope)
-      .createQueryBuilder('orgScope')
-      .select(`DISTINCT orgScope.${scopeField}`, 'value')
-      .where('orgScope.domain_id = :domainId', { domainId: domain.id })
-      .andWhere(`orgScope.${scopeField} IS NOT NULL`)
-      .andWhere(`orgScope.${scopeField} != ''`)
-      .andWhere('orgScope.active = true')
-
-    if (searchTerm) {
-      queryBuilder.andWhere(`orgScope.${scopeField} ILIKE :searchTerm`, {
-        searchTerm: `%${searchTerm}%`
-      })
-    }
-
-    const results = await queryBuilder.getRawMany()
-    return results.map(r => r.value).filter(v => v)
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => [String], { description: 'Get distinct org values' })
-  async kpiOrgValues(
-    @Ctx() context: ResolverContext,
-    @Arg('searchTerm', { nullable: true, description: 'Optional search term to filter org values' }) searchTerm?: string
-  ): Promise<string[]> {
-    const { domain } = context.state
-
-    const queryBuilder = getRepository(KpiOrgScope)
-      .createQueryBuilder('orgScope')
-      .select('DISTINCT orgScope.org', 'value')
-      .where('orgScope.domain_id = :domainId', { domainId: domain.id })
-      .andWhere('orgScope.active = true')
-
-    if (searchTerm) {
-      queryBuilder.andWhere('orgScope.org ILIKE :searchTerm', {
-        searchTerm: `%${searchTerm}%`
-      })
-    }
-
-    const results = await queryBuilder.getRawMany()
-    return results.map(r => r.value)
-  }
-
-  @Directive('@privilege(category: "kpi", privilege: "query", domainOwnerGranted: true, superUserGranted: true)')
-  @Query(returns => KpiOrgScope, { nullable: true, description: 'Find org-scope mapping by org identifier' })
-  async kpiOrgScopeByOrg(
-    @Arg('org', { description: 'Organization identifier to search for' }) org: string,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiOrgScope | undefined> {
-    const { domain } = context.state
-
-    return await getRepository(KpiOrgScope).findOne({
-      where: { domain: { id: domain.id }, org }
-    })
-  }
-
-  @FieldResolver(type => Domain)
-  async domain(@Root() kpiOrgScope: KpiOrgScope): Promise<Domain> {
-    return kpiOrgScope.domainId && (await getRepository(Domain).findOneBy({ id: kpiOrgScope.domainId }))
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() kpiOrgScope: KpiOrgScope): Promise<User> {
-    return kpiOrgScope.creatorId && (await getRepository(User).findOneBy({ id: kpiOrgScope.creatorId }))
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() kpiOrgScope: KpiOrgScope): Promise<User> {
-    return kpiOrgScope.updaterId && (await getRepository(User).findOneBy({ id: kpiOrgScope.updaterId }))
-  }
-}

package/server/service/kpi-org-scope/kpi-org-scope-type.ts

@@ -1,68 +0,0 @@
-import { InputType, Field, ID, ObjectType, Int } from 'type-graphql'
-import { KpiOrgScope } from './kpi-org-scope'
-
-@InputType({ description: 'Input type for creating a new KPI org-scope mapping' })
-export class NewKpiOrgScope {
-  @Field({ description: 'Organizational unit identifier' })
-  org: string
-
-  @Field({ nullable: true, description: 'First scope dimension' })
-  scope01?: string
-
-  @Field({ nullable: true, description: 'Second scope dimension' })
-  scope02?: string
-
-  @Field({ nullable: true, description: 'Third scope dimension' })
-  scope03?: string
-
-  @Field({ nullable: true, description: 'Fourth scope dimension' })
-  scope04?: string
-
-  @Field({ nullable: true, description: 'Fifth scope dimension' })
-  scope05?: string
-
-  @Field({ nullable: true, description: 'Human-readable name or description' })
-  displayName?: string
-
-  @Field({ nullable: true, description: 'Active status' })
-  active?: boolean
-}
-
-@InputType({ description: 'Input type for updating an existing KPI org-scope mapping' })
-export class KpiOrgScopePatch {
-  @Field(type => ID, { description: 'ID of the org-scope mapping to update' })
-  id: string
-
-  @Field({ nullable: true, description: 'Organizational unit identifier' })
-  org?: string
-
-  @Field({ nullable: true, description: 'First scope dimension' })
-  scope01?: string
-
-  @Field({ nullable: true, description: 'Second scope dimension' })
-  scope02?: string
-
-  @Field({ nullable: true, description: 'Third scope dimension' })
-  scope03?: string
-
-  @Field({ nullable: true, description: 'Fourth scope dimension' })
-  scope04?: string
-
-  @Field({ nullable: true, description: 'Fifth scope dimension' })
-  scope05?: string
-
-  @Field({ nullable: true, description: 'Human-readable name or description' })
-  displayName?: string
-
-  @Field({ nullable: true, description: 'Active status' })
-  active?: boolean
-}
-
-@ObjectType({ description: 'List of KPI org-scope mappings with pagination' })
-export class KpiOrgScopeList {
-  @Field(type => [KpiOrgScope], { description: 'Array of KPI org-scope mappings' })
-  items: KpiOrgScope[]
-
-  @Field(type => Int, { description: 'Total count of items' })
-  total: number
-}

package/server/service/kpi-org-scope/kpi-org-scope.ts

@@ -1,123 +0,0 @@
-import {
-  CreateDateColumn,
-  UpdateDateColumn,
-  DeleteDateColumn,
-  Entity,
-  Index,
-  Column,
-  RelationId,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  EntityManager
-} from 'typeorm'
-import { ObjectType, Field, ID } from 'type-graphql'
-
-import { Domain } from '@things-factory/shell'
-import { User } from '@things-factory/auth-base'
-
-@Entity()
-@Index('ix_kpi_org_scope_0', (orgScope: KpiOrgScope) => [orgScope.domain, orgScope.entityType, orgScope.entityId], {
-  unique: true
-})
-@ObjectType({
-  description:
-    'KPI organization scope mapping entity. Maps business entities to various scope dimensions for KPI analysis using generic reference pattern.'
-})
-export class KpiOrgScope {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID, { description: 'Unique identifier for this org-scope mapping.' })
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field({ nullable: true, description: 'Domain (tenant) to which this org-scope mapping belongs.' })
-  domain?: Domain
-
-  @RelationId((orgScope: KpiOrgScope) => orgScope.domain)
-  @Field({ nullable: true, description: 'ID of the domain (tenant) for this org-scope mapping.' })
-  domainId?: string
-
-  @Column()
-  @Field({ description: 'Type of the referenced business entity (e.g., Project, Department, Company, Employee)' })
-  entityType: string
-
-  @Column()
-  @Field({ description: 'ID of the referenced business entity' })
-  entityId: string
-
-  @Column()
-  @Field({ description: 'Name of the referenced business entity (denormalized for performance and convenience)' })
-  entityName: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Legacy org field for backward compatibility' })
-  org?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'First scope dimension (e.g., geographical region, business unit)' })
-  scope01?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Second scope dimension (e.g., product line, customer segment)' })
-  scope02?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Third scope dimension (e.g., process type, technology stack)' })
-  scope03?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fourth scope dimension (e.g., cost center, profit center)' })
-  scope04?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true, description: 'Fifth scope dimension (e.g., risk level, priority tier)' })
-  scope05?: string
-
-  @CreateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this org-scope mapping was created.' })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true, description: 'Timestamp when this org-scope mapping was last updated.' })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who created this org-scope mapping.' })
-  creator?: User
-
-  @RelationId((orgScope: KpiOrgScope) => orgScope.creator)
-  @Field({ nullable: true, description: 'ID of the user who created this org-scope mapping.' })
-  creatorId?: string
-
-  @ManyToOne(type => User, { nullable: true })
-  @Field(type => User, { nullable: true, description: 'User who last updated this org-scope mapping.' })
-  updater?: User
-
-  @RelationId((orgScope: KpiOrgScope) => orgScope.updater)
-  @Field({ nullable: true, description: 'ID of the user who last updated this org-scope mapping.' })
-  updaterId?: string
-
-  // Helper methods for Generic Reference Pattern
-  async getReferencedEntity(entityManager: EntityManager): Promise<any> {
-    try {
-      const repository = entityManager.getRepository(this.entityType)
-      return await repository.findOne({ where: { id: this.entityId } })
-    } catch (error) {
-      console.warn(`Failed to get referenced entity ${this.entityType}:${this.entityId}`, error)
-      return null
-    }
-  }
-
-  async validateEntityReference(entityManager: EntityManager): Promise<boolean> {
-    try {
-      const entity = await this.getReferencedEntity(entityManager)
-      return !!entity
-    } catch {
-      return false
-    }
-  }
-
-  // Convenience getter for display purposes
-  get displayName(): string {
-    return this.entityName || `${this.entityType}:${this.entityId}` || this.org || 'Unknown'
-  }
-}

package/server/service/kpi-scope/index.ts

@@ -1,11 +0,0 @@
-import { KpiScope } from './kpi-scope'
-import { KpiScopeQuery } from './kpi-scope-query'
-import { KpiScopeMutation } from './kpi-scope-mutation'
-
-export const entities = [KpiScope]
-export const resolvers = [KpiScopeQuery, KpiScopeMutation]
-
-export * from './kpi-scope'
-export * from './kpi-scope-query'
-export * from './kpi-scope-mutation'
-export * from './kpi-scope-type'

package/server/service/kpi-scope/kpi-scope-mutation.ts

@@ -1,129 +0,0 @@
-import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
-import { In } from 'typeorm'
-import { getRepository } from '@things-factory/shell'
-import type ResolverContext from '@things-factory/auth-base'
-
-import { KpiScope } from './kpi-scope'
-import { NewKpiScope, KpiScopePatch } from './kpi-scope-type'
-
-@Resolver(KpiScope)
-export class KpiScopeMutation {
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiScope, { description: 'Create a new scope dimension definition' })
-  async createKpiScope(
-    @Arg('kpiScope') kpiScope: NewKpiScope,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiScope> {
-    const { domain, user, tx } = context.state
-
-    const result = await getRepository(KpiScope, tx).save({
-      ...kpiScope,
-      domain,
-      creator: user,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => KpiScope, { description: 'Update a scope dimension definition' })
-  async updateKpiScope(
-    @Arg('id') id: string,
-    @Arg('patch') patch: KpiScopePatch,
-    @Ctx() context: ResolverContext
-  ): Promise<KpiScope> {
-    const { domain, user, tx } = context.state
-
-    const repository = getRepository(KpiScope, tx)
-    const kpiScope = await repository.findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-
-    const result = await repository.save({
-      ...kpiScope,
-      ...patch,
-      updater: user
-    })
-
-    return result
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => [KpiScope], { description: "Update multiple scope dimension definitions" })
-  async updateMultipleKpiScope(
-    @Arg('patches', type => [KpiScopePatch]) patches: KpiScopePatch[],
-    @Ctx() context: ResolverContext
-  ): Promise<KpiScope[]> {
-    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 kpiScopeRepo = getRepository(KpiScope, tx)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await kpiScopeRepo.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 kpiScope = await kpiScopeRepo.findOneBy({ id: updateRecord.id })
-
-        const result = await kpiScopeRepo.save({
-          ...kpiScope,
-          ...updateRecord,
-          updater: user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'Delete a scope dimension definition' })
-  async deleteKpiScope(@Arg('id') id: string, @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiScope, tx).delete({ domain: { id: domain.id }, id })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Directive('@privilege(category: "kpi", privilege: "mutation", domainOwnerGranted: true, superUserGranted: true)')
-  @Mutation(returns => Boolean, { description: 'Delete multiple scope dimension definitions' })
-  async deleteKpiScopes(
-    @Arg('ids', type => [String]) ids: string[],
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await getRepository(KpiScope, tx).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-}