@dotbep/core 0.2.7 → 0.2.8

package/src/entities/members.ts

@@ -1,137 +0,0 @@
-import type { BEP, Member, Team } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { MemberSchema } from '../types/schema.js'
-import type { MemberResolved } from '../types/resolved.js'
-
-export class Members extends Entity<Member> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().members,
-      getBep,
-      {
-        key: 'members',
-        idField: 'email',
-        schema: MemberSchema,
-      },
-    )
-  }
-
-  listResolved(): MemberResolved[] {
-    const bep = this.getBep()
-    return bep.members.map(m => {
-      const team = bep.teams.find(t => (t.memberEmails ?? []).includes(m.email))
-      return {
-        ...m,
-        role: bep.roles.find(r => r.id === m.roleId) ?? null,
-        team: team ? { id: team.id, name: team.name } : null,
-        isRepresentative: team?.representativeEmail === m.email,
-      }
-    })
-  }
-
-  addToTeam(items: Array<Member & { teamId: Team['id']; isRepresentative?: boolean }>): {
-    succeeded: MemberResolved[]
-    failed: { input: unknown; error: string }[]
-  } {
-    const succeeded: MemberResolved[] = []
-    const failed: { input: unknown; error: string }[] = []
-
-    for (const item of items) {
-      const bep = this.getBep()
-      const team = bep.teams.find(t => t.id === item.teamId)
-      if (!team) { failed.push({ input: item, error: `Team not found: ${item.teamId}` }); continue }
-
-      const { teamId, isRepresentative, ...member } = item
-      const result = this.add([member])
-      if (result.failed.length > 0) { failed.push({ input: item, error: result.failed[0].error }); continue }
-
-      team.memberEmails ??= []
-      if (!team.memberEmails.includes(item.email)) team.memberEmails.push(item.email)
-      if (isRepresentative) team.representativeEmail = item.email
-
-      const resolved = this.listResolved().find(m => m.email === item.email)!
-      succeeded.push(resolved)
-    }
-
-    return { succeeded, failed }
-  }
-
-  updateInTeam(items: Array<Partial<Member> & { email: Member['email']; teamId?: Team['id']; isRepresentative?: boolean }>): {
-    succeeded: Array<{ email: Member['email']; after: MemberResolved }>
-    failed: { email: Member['email']; error: string }[]
-  } {
-    const succeeded: Array<{ email: Member['email']; after: MemberResolved }> = []
-    const failed: { email: Member['email']; error: string }[] = []
-
-    for (const item of items) {
-      const bep = this.getBep()
-      const { teamId, isRepresentative, ...fields } = item
-
-      if (teamId !== undefined && !bep.teams.find(t => t.id === teamId)) {
-        failed.push({ email: item.email, error: `Team not found: ${teamId}` }); continue
-      }
-
-      const result = this.update([fields])
-      if (result.failed.length > 0) { failed.push({ email: item.email, error: result.failed[0].error }); continue }
-
-      if (teamId !== undefined) {
-        const newTeam = bep.teams.find(t => t.id === teamId)!
-        const oldTeam = bep.teams.find(t => (t.memberEmails ?? []).includes(item.email))
-        if (oldTeam && oldTeam.id !== teamId) {
-          oldTeam.memberEmails = (oldTeam.memberEmails ?? []).filter(e => e !== item.email)
-          if (oldTeam.representativeEmail === item.email) oldTeam.representativeEmail = undefined
-        }
-        newTeam.memberEmails ??= []
-        if (!newTeam.memberEmails.includes(item.email)) newTeam.memberEmails.push(item.email)
-      }
-
-      if (isRepresentative !== undefined) {
-        const team = bep.teams.find(t => (t.memberEmails ?? []).includes(item.email))
-        if (team) team.representativeEmail = isRepresentative ? item.email : (team.representativeEmail === item.email ? undefined : team.representativeEmail)
-      }
-
-      const resolved = this.listResolved().find(m => m.email === item.email)!
-      succeeded.push({ email: item.email, after: resolved })
-    }
-
-    return { succeeded, failed }
-  }
-
-  removeFromBep(emails: Member['email'][]): {
-    succeeded: MemberResolved[]
-    failed: { email: Member['email']; error: string }[]
-  } {
-    const succeeded: MemberResolved[] = []
-    const failed: { email: Member['email']; error: string }[] = []
-
-    for (const email of emails) {
-      const bep = this.getBep()
-      const snapshot = this.listResolved().find(m => m.email === email)
-      if (!snapshot) { failed.push({ email, error: `Not found: ${email}` }); continue }
-
-      // Clean team refs so integrity check doesn't block removal
-      for (const t of bep.teams) {
-        if (t.memberEmails) t.memberEmails = t.memberEmails.filter(e => e !== email)
-        if (t.representativeEmail === email) t.representativeEmail = undefined
-      }
-
-      const result = this.remove([email])
-      if (result.failed.length > 0) {
-        // Restore team refs on failure (e.g. notes blocking)
-        if (snapshot.team) {
-          const team = bep.teams.find(t => t.id === snapshot.team!.id)
-          if (team) {
-            team.memberEmails ??= []
-            if (!team.memberEmails.includes(email)) team.memberEmails.push(email)
-            if (snapshot.isRepresentative) team.representativeEmail = email
-          }
-        }
-        failed.push({ email, error: result.failed[0].error }); continue
-      }
-
-      succeeded.push(snapshot)
-    }
-
-    return { succeeded, failed }
-  }
-}

package/src/entities/milestones.ts

@@ -1,32 +0,0 @@
-import type { BEP, Milestone } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { MilestoneSchema } from '../types/schema.js'
-import type { MilestoneResolved } from '../types/resolved.js'
-
-export class Milestones extends Entity<Milestone, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().milestones,
-      getBep,
-      {
-        key: 'milestones',
-        schema: MilestoneSchema,
-        autoId: true,
-        beforeRemove: (id, bep) => {
-          for (const loin of bep.loin) {
-            const ref = loin.milestones?.find(m => m.milestoneId === id)
-            if (ref) throw new Error(`Referenced by: loin["${loin.id}"].milestones[milestoneId="${id}"]`)
-          }
-        },
-      },
-    )
-  }
-
-  listResolved(): MilestoneResolved[] {
-    const bep = this.getBep()
-    return bep.milestones.map(m => ({
-      ...m,
-      phase: bep.phases.find(p => p.id === m.phaseId) ?? null,
-    }))
-  }
-}

package/src/entities/notes.ts

@@ -1,27 +0,0 @@
-import type { BEP, Note } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { NoteSchema } from '../types/schema.js'
-import type { NoteResolved } from '../types/resolved.js'
-import type { Members } from './members.js'
-
-export class Notes extends Entity<Note, true> {
-  constructor(getBep: () => BEP, private readonly getMembers: () => Members) {
-    super(
-      () => getBep().notes,
-      getBep,
-      {
-        key: 'notes',
-        schema: NoteSchema,
-        autoId: true,
-      },
-    )
-  }
-
-  listResolved(): NoteResolved[] {
-    const memberMap = new Map(this.getMembers().listResolved().map(m => [m.email, m]))
-    return this.getBep().notes.map(n => ({
-      ...n,
-      member: memberMap.get(n.memberEmail) ?? null,
-    }))
-  }
-}

package/src/entities/objectives.ts

@@ -1,17 +0,0 @@
-import type { BEP, Objective } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { ObjectiveSchema } from '../types/schema.js'
-
-export class Objectives extends Entity<Objective, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().objectives,
-      getBep,
-      {
-        key: 'objectives',
-        schema: ObjectiveSchema,
-        autoId: true,
-      },
-    )
-  }
-}

package/src/entities/phases.ts

@@ -1,17 +0,0 @@
-import type { BEP, Phase } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { PhaseSchema } from '../types/schema.js'
-
-export class Phases extends Entity<Phase, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().phases,
-      getBep,
-      {
-        key: 'phases',
-        schema: PhaseSchema,
-        autoId: true,
-      },
-    )
-  }
-}

package/src/entities/remoteData.ts

@@ -1,17 +0,0 @@
-import type { BEP, RemoteData } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { RemoteDataSchema } from '../types/schema.js'
-
-export class RemoteDataEntity extends Entity<RemoteData, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().remoteData,
-      getBep,
-      {
-        key:    'remoteData',
-        schema: RemoteDataSchema,
-        autoId: true,
-      },
-    )
-  }
-}

package/src/entities/resolvers.ts

@@ -1,20 +0,0 @@
-import type { BEP, Resolver } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { ResolverSchema } from '../types/schema.js'
-
-export class Resolvers extends Entity<Resolver> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().resolvers,
-      getBep,
-      {
-        key: 'resolvers',
-        schema: ResolverSchema,
-        beforeRemove: (id, bep) => {
-          const ref = bep.remoteData.find(r => r.resolverId === id)
-          if (ref) throw new Error(`Referenced by: remoteData["${ref.id}"].resolverId`)
-        },
-      },
-    )
-  }
-}

package/src/entities/roles.ts

@@ -1,29 +0,0 @@
-import type { BEP, Role } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { RoleSchema } from '../types/schema.js'
-
-export class Roles extends Entity<Role, true> {
-  constructor(getBep: () => BEP) {
-    super(
-      () => getBep().roles,
-      getBep,
-      {
-        key: 'roles',
-        schema: RoleSchema,
-        autoId: true,
-        beforeRemove: (id, bep) => {
-          const raciFields = ['responsibleRoleIds', 'accountableRoleIds', 'consultedRoleIds', 'informedRoleIds'] as const
-          for (const wf of bep.workflows) {
-            for (const [nodeKey, node] of Object.entries(wf.diagram.nodes)) {
-              if (node.type !== 'process') continue
-              for (const field of raciFields) {
-                if (node[field]?.includes(id))
-                  throw new Error(`Referenced by: workflows["${wf.id}"].diagram.nodes["${nodeKey}"].${field}`)
-              }
-            }
-          }
-        },
-      },
-    )
-  }
-}

package/src/entities/softwares.ts

@@ -1,26 +0,0 @@
-import type { BEP, Software } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { SoftwareSchema } from '../types/schema.js'
-import type { AssetTypeResolved, SoftwareResolved } from '../types/resolved.js'
-import type { AssetTypes } from './assetTypes.js'
-
-export class Softwares extends Entity<Software> {
-  constructor(getBep: () => BEP, private readonly getAssetTypes: () => AssetTypes) {
-    super(
-      () => getBep().softwares,
-      getBep,
-      {
-        key: 'softwares',
-        schema: SoftwareSchema,
-      },
-    )
-  }
-
-  listResolved(): SoftwareResolved[] {
-    const assetTypeMap = new Map(this.getAssetTypes().listResolved().map(dt => [dt.id, dt]))
-    return this.getBep().softwares.map(s => ({
-      ...s,
-      assetTypes: (s.assetTypeIds ?? []).map(id => assetTypeMap.get(id)).filter(Boolean) as AssetTypeResolved[],
-    }))
-  }
-}

package/src/entities/standards.ts

@@ -1,68 +0,0 @@
-import type JSZip from 'jszip'
-import type { BEP, Standard } from '../types/schema.js'
-import { Entity, type BulkResult } from '../base/entity.js'
-import { StandardSchema } from '../types/schema.js'
-
-/** Input for Standards.add(): accepts markdown text in `content` instead of a file path. */
-export type StandardAddInput = Omit<Standard, 'id' | 'contentPath'> & { content: string }
-
-export class Standards extends Entity<Standard, true> {
-  constructor(getBep: () => BEP, private getZip: () => JSZip) {
-    super(
-      () => getBep().standards,
-      getBep,
-      { key: 'standards', schema: StandardSchema, autoId: true },
-    )
-  }
-
-  /**
-   * Accepts markdown text in `content` (user-facing).
-   * Generates a UUID-based path, writes the text to the zip,
-   * and stores the path in Standard.contentPath.
-   * Union with AddInput<Standard> satisfies the base class contract.
-   */
-  override add(inputs: (StandardAddInput | Omit<Standard, 'id'>)[]): BulkResult<Standard> {
-    const withPaths = inputs.map(input => {
-      const path = `standards/${globalThis.crypto.randomUUID()}.md`
-      if ('content' in input) {
-        const { content, ...rest } = input
-        this.getZip().file(path, content)
-        return { ...rest, contentPath: path }
-      }
-      this.getZip().file(path, '')
-      return { ...input, contentPath: path }
-    })
-    return super.add(withPaths)
-  }
-
-  /** Removes standards and deletes their .md files from the zip. */
-  override remove(ids: Standard['id'][]) {
-    const paths = new Map(
-      ids
-        .map(id => [id, this.list().find(s => s.id === id)?.contentPath])
-        .filter((e): e is [string, string] => e[1] !== undefined),
-    )
-    const result = super.remove(ids)
-    for (const id of result.succeeded) {
-      const path = paths.get(id)
-      if (path) this.getZip().remove(path)
-    }
-    return result
-  }
-
-  /** Returns the markdown text content of the given standard. */
-  async getContent(id: Standard['id']): Promise<string> {
-    const std = this.list().find(s => s.id === id)
-    if (!std) throw new Error(`Standard not found: ${id}`)
-    const file = this.getZip().file(std.contentPath)
-    if (!file) throw new Error(`Content file not found: ${std.contentPath}`)
-    return file.async('string')
-  }
-
-  /** Writes new markdown text content for the given standard. */
-  setContent(id: Standard['id'], text: string): void {
-    const std = this.list().find(s => s.id === id)
-    if (!std) throw new Error(`Standard not found: ${id}`)
-    this.getZip().file(std.contentPath, text)
-  }
-}

package/src/entities/teams.ts

@@ -1,42 +0,0 @@
-import type { BEP, Discipline, Team } from '../types/schema.js'
-import { Entity } from '../base/entity.js'
-import { TeamSchema } from '../types/schema.js'
-import type { MemberResolved, TeamResolved } from '../types/resolved.js'
-import type { Members } from './members.js'
-import { validateTokenValue } from '../utils/naming.js'
-
-export class Teams extends Entity<Team> {
-  constructor(getBep: () => BEP, private readonly getMembers: () => Members) {
-    super(
-      () => getBep().teams,
-      getBep,
-      {
-        key: 'teams',
-        schema: TeamSchema,
-        validate: (team, bep) => {
-          const errors: string[] = []
-          const tokenErr = validateTokenValue('team', team.id, bep.deliverableNamingConvention)
-          if (tokenErr) errors.push(tokenErr)
-          if (team.representativeEmail && !(team.memberEmails ?? []).includes(team.representativeEmail))
-            errors.push(`representativeEmail "${team.representativeEmail}" is not a member of this team`)
-          return errors
-        },
-        beforeRemove: (id, bep) => {
-          if (bep.project.clientId === id)
-            throw new Error('Referenced by: project.clientId')
-        },
-      },
-    )
-  }
-
-  listResolved(): TeamResolved[] {
-    const bep = this.getBep()
-    const memberMap = new Map(this.getMembers().listResolved().map(m => [m.email, m]))
-    return bep.teams.map(t => ({
-      ...t,
-      representative: memberMap.get(t.representativeEmail ?? '') ?? null,
-      members: (t.memberEmails ?? []).map(email => memberMap.get(email)).filter(Boolean) as MemberResolved[],
-      disciplines: (t.disciplineIds ?? []).map(id => bep.disciplines.find(d => d.id === id)).filter(Boolean) as Discipline[],
-    }))
-  }
-}