@pikku/mongodb 0.12.20 → 0.12.22

package/src/mongodb-services.test.ts

@@ -1,235 +0,0 @@
-import { describe, test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { MongoClient, type Db } from 'mongodb'
-import { MongoMemoryServer } from 'mongodb-memory-server'
-import { defineServiceTests } from '@pikku/core/testing'
-
-import { MongoDBChannelStore } from './mongodb-channel-store.js'
-import { MongoDBEventHubStore } from './mongodb-eventhub-store.js'
-import { MongoDBWorkflowService } from './mongodb-workflow-service.js'
-import { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'
-import { MongoDBDeploymentService } from './mongodb-deployment-service.js'
-import { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js'
-import { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
-import { MongoDBSecretService } from './mongodb-secret-service.js'
-import { MongoDBSessionStore } from './mongodb-session-store.js'
-
-function registerTests(name: string, getDb: () => Db) {
-  defineServiceTests({
-    name,
-    services: {
-      channelStore: async () => {
-        const s = new MongoDBChannelStore(getDb())
-        await s.init()
-        return s
-      },
-      eventHubStore: async () => {
-        const s = new MongoDBEventHubStore(getDb())
-        await s.init()
-        return s
-      },
-      workflowService: async () => {
-        const s = new MongoDBWorkflowService(getDb())
-        await s.init()
-        return s
-      },
-      workflowRunService: async () => new MongoDBWorkflowRunService(getDb()),
-      deploymentService: async () => {
-        const s = new MongoDBDeploymentService(
-          { heartbeatInterval: 60000, heartbeatTtl: 120000 },
-          getDb()
-        )
-        await s.init()
-        return s
-      },
-      agentStorageService: async () => {
-        const s = new MongoDBAgentStorageService(getDb())
-        await s.init()
-        return s
-      },
-      agentRunService: async () => new MongoDBAgentRunService(getDb()),
-      secretService: async (config) => {
-        const s = new MongoDBSecretService(getDb(), config)
-        await s.init()
-        return s
-      },
-      sessionStore: async () => {
-        const s = new MongoDBSessionStore(getDb())
-        await s.init()
-        return s
-      },
-    },
-  })
-
-  describe(`MongoDBSecretService audit [${name}]`, () => {
-    const kek = 'test-key-encryption-key-32chars!'
-
-    test('audit logs writes, reads, and deletes', async () => {
-      const service = new MongoDBSecretService(getDb(), {
-        key: kek,
-        audit: true,
-        auditReads: true,
-      })
-      await service.init()
-      await service.setSecret('audit-test', 'value')
-      await service.getSecret('audit-test')
-      await service.deleteSecret('audit-test')
-
-      const logs = await getDb()
-        .collection('secrets_audit')
-        .find({ secretKey: 'audit-test' })
-        .sort({ performedAt: 1 })
-        .toArray()
-
-      assert.equal(logs.length, 3)
-      assert.equal(logs[0]!.action, 'write')
-      assert.equal(logs[1]!.action, 'read')
-      assert.equal(logs[2]!.action, 'delete')
-    })
-
-    test('audit skips reads when auditReads is false', async () => {
-      const service = new MongoDBSecretService(getDb(), {
-        key: kek,
-        audit: true,
-        auditReads: false,
-      })
-      await service.init()
-      await service.setSecret('no-read-audit', 'value')
-      await service.getSecret('no-read-audit')
-
-      const logs = await getDb()
-        .collection('secrets_audit')
-        .find({ secretKey: 'no-read-audit' })
-        .toArray()
-
-      assert.equal(logs.length, 1)
-      assert.equal(logs[0]!.action, 'write')
-    })
-  })
-
-  describe(`MongoDBSecretService decryption failures [${name}]`, () => {
-    const kek = 'test-key-encryption-key-32chars!'
-    const otherKek = 'a-totally-different-kek-32chars!'
-
-    test('getSecrets throws naming a secret it cannot decrypt', async () => {
-      const writer = new MongoDBSecretService(getDb(), { key: kek })
-      await writer.init()
-      await writer.setSecret('undecryptable', { token: 'abc' })
-
-      const reader = new MongoDBSecretService(getDb(), { key: otherKek })
-      await reader.init()
-
-      await assert.rejects(
-        () => reader.getSecrets(['undecryptable']),
-        (error: Error) => {
-          assert.equal(
-            error.message,
-            'Failed to decrypt secret "undecryptable" (key_version 1): ' +
-              'the configured KEK does not match the key it was wrapped under'
-          )
-          assert.ok(error.cause, 'the underlying crypto failure is preserved')
-          return true
-        }
-      )
-    })
-
-    test('getSecrets throws when no KEK is available for a stored key_version', async () => {
-      const writer = new MongoDBSecretService(getDb(), {
-        key: kek,
-        keyVersion: 7,
-      })
-      await writer.init()
-      await writer.setSecret('old-version', 'value')
-
-      const reader = new MongoDBSecretService(getDb(), {
-        key: kek,
-        keyVersion: 8,
-      })
-      await reader.init()
-
-      await assert.rejects(
-        () => reader.getSecrets(['old-version']),
-        (error: Error) => {
-          assert.equal(
-            error.message,
-            'Failed to decrypt secret "old-version" (key_version 7): ' +
-              'the configured KEK does not match the key it was wrapped under'
-          )
-          return true
-        }
-      )
-    })
-
-    test('getSecrets returns every secret when they all decrypt', async () => {
-      const service = new MongoDBSecretService(getDb(), { key: kek })
-      await service.init()
-      await service.setSecret('batch-a', { v: 1 })
-      await service.setSecret('batch-b', 'two')
-
-      const out = await service.getSecrets<{
-        'batch-a': { v: number }
-        'batch-b': string
-      }>(['batch-a', 'batch-b'])
-
-      assert.deepEqual(out['batch-a']!.reveal(), { v: 1 })
-      assert.equal(out['batch-b']!.reveal(), 'two')
-    })
-
-    test('getSecrets omits keys that were never stored', async () => {
-      const service = new MongoDBSecretService(getDb(), { key: kek })
-      await service.init()
-      await service.setSecret('present', 'here')
-
-      const out = await service.getSecrets(['present', 'never-stored'])
-
-      assert.deepEqual(Object.keys(out), ['present'])
-      assert.equal(out.present!.reveal(), 'here')
-    })
-  })
-}
-
-describe('MongoDB Services - In-Memory', () => {
-  let mongod: MongoMemoryServer
-  let client: MongoClient
-  let db: Db
-
-  before(async () => {
-    mongod = await MongoMemoryServer.create()
-    const uri = mongod.getUri()
-    client = new MongoClient(uri)
-    await client.connect()
-    db = client.db('pikku_test')
-  })
-
-  after(async () => {
-    await client.close()
-    await mongod.stop()
-  })
-
-  registerTests('MongoMemory', () => db)
-})
-
-describe(
-  'MongoDB Services - Real',
-  {
-    skip: !process.env.MONGODB_URL ? 'MONGODB_URL not set' : undefined,
-  },
-  () => {
-    let client: MongoClient
-    let db: Db
-
-    before(async () => {
-      client = new MongoClient(process.env.MONGODB_URL!)
-      await client.connect()
-      db = client.db('pikku_test')
-      await db.dropDatabase()
-    })
-
-    after(async () => {
-      if (db) await db.dropDatabase()
-      if (client) await client.close()
-    })
-
-    registerTests('Real MongoDB', () => db)
-  }
-)

package/src/mongodb-session-store.ts

@@ -1,50 +0,0 @@
-import type { SessionStore } from '@pikku/core/services'
-import type { CoreUserSession } from '@pikku/core/types'
-import type { Db, Collection } from 'mongodb'
-
-interface SessionDoc {
-  _id: string
-  session: any
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class MongoDBSessionStore implements SessionStore {
-  private initialized = false
-  private sessions!: Collection<SessionDoc>
-
-  constructor(private db: Db) {}
-
-  public async init(): Promise<void> {
-    if (this.initialized) return
-
-    this.sessions = this.db.collection<SessionDoc>('pikkuUserSessions')
-    this.initialized = true
-  }
-
-  async get(pikkuUserId: string): Promise<CoreUserSession | undefined> {
-    const doc = await this.sessions.findOne({ _id: pikkuUserId })
-    if (!doc) {
-      return undefined
-    }
-    return doc.session as CoreUserSession
-  }
-
-  async set(pikkuUserId: string, session: CoreUserSession): Promise<void> {
-    const now = new Date()
-    await this.sessions.updateOne(
-      { _id: pikkuUserId },
-      {
-        $set: { session, updatedAt: now },
-        $setOnInsert: { createdAt: now },
-      },
-      { upsert: true }
-    )
-  }
-
-  async clear(pikkuUserId: string): Promise<void> {
-    await this.sessions.deleteOne({ _id: pikkuUserId })
-  }
-
-  public async close(): Promise<void> {}
-}

package/src/mongodb-workflow-run-service.ts

@@ -1,235 +0,0 @@
-import type {
-  WorkflowPlannedStep,
-  WorkflowRun,
-  StepState,
-  WorkflowStatus,
-  WorkflowRunService,
-} from '@pikku/core/workflow'
-import type { Db, Collection } from 'mongodb'
-
-interface WorkflowRunDoc {
-  _id: string
-  workflow: string
-  status: string
-  input: any
-  output: any | null
-  error: any | null
-  state: Record<string, unknown>
-  inline: boolean
-  graphHash: string | null
-  deterministic?: boolean
-  plannedSteps?: WorkflowPlannedStep[]
-  wire: any | null
-  createdAt: Date
-  updatedAt: Date
-}
-
-interface WorkflowStepDoc {
-  _id: string
-  workflowRunId: string
-  stepName: string
-  rpcName: string | null
-  data: any | null
-  status: string
-  result: any | null
-  error: any | null
-  branchTaken: string | null
-  retries: number | null
-  retryDelay: string | null
-  createdAt: Date
-  updatedAt: Date
-}
-
-interface WorkflowStepHistoryDoc {
-  _id: string
-  workflowStepId: string
-  status: string
-  result: any | null
-  error: any | null
-  createdAt: Date
-  runningAt: Date | null
-  scheduledAt: Date | null
-  succeededAt: Date | null
-  failedAt: Date | null
-}
-
-interface WorkflowVersionDoc {
-  workflowName: string
-  graphHash: string
-  graph: any
-  source: string
-  createdAt: Date
-}
-
-export class MongoDBWorkflowRunService implements WorkflowRunService {
-  private runs: Collection<WorkflowRunDoc>
-  private steps: Collection<WorkflowStepDoc>
-  private stepHistory: Collection<WorkflowStepHistoryDoc>
-  private versions: Collection<WorkflowVersionDoc>
-
-  constructor(db: Db) {
-    this.runs = db.collection<WorkflowRunDoc>('workflow_runs')
-    this.steps = db.collection<WorkflowStepDoc>('workflow_step')
-    this.stepHistory = db.collection<WorkflowStepHistoryDoc>(
-      'workflow_step_history'
-    )
-    this.versions = db.collection<WorkflowVersionDoc>('workflow_versions')
-  }
-
-  async listRuns(options?: {
-    workflowName?: string
-    status?: string
-    limit?: number
-    offset?: number
-  }): Promise<WorkflowRun[]> {
-    const { workflowName, status, limit = 50, offset = 0 } = options ?? {}
-
-    const filter: Record<string, any> = {}
-    if (workflowName) filter.workflow = workflowName
-    if (status) filter.status = status
-
-    const result = await this.runs
-      .find(filter)
-      .sort({ createdAt: -1 })
-      .skip(offset)
-      .limit(limit)
-      .toArray()
-
-    return result.map((row) => this.mapRunRow(row))
-  }
-
-  async getRun(id: string): Promise<WorkflowRun | null> {
-    const row = await this.runs.findOne({ _id: id })
-    if (!row) return null
-    return this.mapRunRow(row)
-  }
-
-  async getRunSteps(
-    runId: string
-  ): Promise<
-    Array<StepState & { stepName: string; rpcName?: string; data?: any }>
-  > {
-    const result = await this.steps
-      .find({ workflowRunId: runId })
-      .sort({ createdAt: 1 })
-      .toArray()
-
-    const stepIds = result.map((r) => r._id)
-    const historyCounts = await this.stepHistory
-      .aggregate<{
-        _id: string
-        count: number
-      }>([
-        { $match: { workflowStepId: { $in: stepIds } } },
-        { $group: { _id: '$workflowStepId', count: { $sum: 1 } } },
-      ])
-      .toArray()
-
-    const countMap = new Map(historyCounts.map((h) => [h._id, h.count]))
-
-    return result.map((row) => ({
-      stepId: row._id,
-      stepName: row.stepName,
-      rpcName: row.rpcName ?? undefined,
-      data: row.data ?? undefined,
-      status: row.status as StepState['status'],
-      result: row.result ?? undefined,
-      error: row.error ?? undefined,
-      attemptCount: countMap.get(row._id) ?? 1,
-      retries: row.retries != null ? Number(row.retries) : undefined,
-      retryDelay: row.retryDelay ?? undefined,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-    }))
-  }
-
-  async getRunHistory(
-    runId: string
-  ): Promise<Array<StepState & { stepName: string }>> {
-    const steps = await this.steps.find({ workflowRunId: runId }).toArray()
-
-    const stepMap = new Map(steps.map((s) => [s._id, s]))
-    const stepIds = steps.map((s) => s._id)
-
-    const history = await this.stepHistory
-      .find({ workflowStepId: { $in: stepIds } })
-      .sort({ createdAt: 1 })
-      .toArray()
-
-    let attemptCounters: Record<string, number> = {}
-    return history.map((row) => {
-      const stepId = row.workflowStepId
-      const step = stepMap.get(stepId)!
-      attemptCounters[stepId] = (attemptCounters[stepId] ?? 0) + 1
-
-      return {
-        stepId,
-        stepName: step.stepName,
-        status: row.status as StepState['status'],
-        result: row.result ?? undefined,
-        error: row.error ?? undefined,
-        attemptCount: attemptCounters[stepId]!,
-        retries: step.retries != null ? Number(step.retries) : undefined,
-        retryDelay: step.retryDelay ?? undefined,
-        createdAt: new Date(row.createdAt),
-        updatedAt: new Date(row.createdAt),
-        runningAt: row.runningAt ? new Date(row.runningAt) : undefined,
-        scheduledAt: row.scheduledAt ? new Date(row.scheduledAt) : undefined,
-        succeededAt: row.succeededAt ? new Date(row.succeededAt) : undefined,
-        failedAt: row.failedAt ? new Date(row.failedAt) : undefined,
-      }
-    })
-  }
-
-  async getDistinctWorkflowNames(): Promise<string[]> {
-    const result = await this.runs.distinct('workflow')
-    return result.sort()
-  }
-
-  async getWorkflowVersion(
-    name: string,
-    graphHash: string
-  ): Promise<{ graph: any; source: string } | null> {
-    const row = await this.versions.findOne({
-      workflowName: name,
-      graphHash,
-    })
-
-    if (!row) return null
-    return {
-      graph: row.graph,
-      source: row.source,
-    }
-  }
-
-  async deleteRun(id: string): Promise<boolean> {
-    const steps = await this.steps.find({ workflowRunId: id }).toArray()
-    const stepIds = steps.map((s) => s._id)
-
-    if (stepIds.length > 0) {
-      await this.stepHistory.deleteMany({ workflowStepId: { $in: stepIds } })
-      await this.steps.deleteMany({ workflowRunId: id })
-    }
-
-    const result = await this.runs.deleteOne({ _id: id })
-    return result.deletedCount > 0
-  }
-
-  private mapRunRow(row: WorkflowRunDoc): WorkflowRun {
-    return {
-      id: row._id,
-      workflow: row.workflow,
-      status: row.status as WorkflowStatus,
-      input: row.input,
-      output: row.output ?? undefined,
-      error: row.error ?? undefined,
-      inline: row.inline,
-      graphHash: row.graphHash ?? undefined,
-      deterministic: row.deterministic ?? undefined,
-      plannedSteps: row.plannedSteps ?? undefined,
-      wire: row.wire ?? { type: 'unknown' },
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-    }
-  }
-}