@pikku/core 0.12.106 → 0.12.111

package/src/services/in-memory-queue-service.test.ts

@@ -1,162 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { InMemoryQueueService } from './in-memory-queue-service.js'
-import { wireQueueWorker } from '../wirings/queue/queue-runner.js'
-import { resetPikkuState, pikkuState } from '../pikku-state.js'
-
-beforeEach(() => {
-  resetPikkuState()
-  pikkuState(null, 'package', 'singletonServices', {
-    logger: { error() {}, info() {}, warn() {}, debug() {} },
-  } as any)
-  pikkuState(null, 'package', 'factories', {
-    createWireServices: async () => ({}),
-  } as any)
-})
-
-// Register a queue worker whose handler runs `behavior` (which may throw) and
-// counts invocations. Returns the live call counter.
-const registerWorker = (
-  queueName: string,
-  behavior: (count: number) => void
-) => {
-  const calls = { count: 0 }
-  const funcId = `queue_${queueName}`
-  pikkuState(null, 'queue', 'meta')[queueName] = {
-    pikkuFuncId: funcId,
-    name: queueName,
-  }
-  pikkuState(null, 'function', 'meta')[funcId] = {
-    pikkuFuncId: funcId,
-    inputSchemaName: null,
-    outputSchemaName: null,
-    sessionless: true,
-  } as any
-  wireQueueWorker({
-    name: queueName,
-    func: {
-      auth: false,
-      func: async () => {
-        calls.count++
-        behavior(calls.count)
-      },
-    },
-  } as any)
-  return calls
-}
-
-const waitUntil = async (
-  predicate: () => boolean,
-  timeoutMs = 2000
-): Promise<boolean> => {
-  const deadline = Date.now() + timeoutMs
-  while (Date.now() < deadline) {
-    if (predicate()) return true
-    await new Promise((r) => setTimeout(r, 10))
-  }
-  return predicate()
-}
-
-// Register a queue worker that records the payload each delivery carried.
-const registerRecordingWorker = (queueName: string) => {
-  const received: any[] = []
-  const funcId = `queue_${queueName}`
-  pikkuState(null, 'queue', 'meta')[queueName] = {
-    pikkuFuncId: funcId,
-    name: queueName,
-  }
-  pikkuState(null, 'function', 'meta')[funcId] = {
-    pikkuFuncId: funcId,
-    inputSchemaName: null,
-    outputSchemaName: null,
-    sessionless: true,
-  } as any
-  wireQueueWorker({
-    name: queueName,
-    func: {
-      auth: false,
-      func: async (_services: any, data: any) => {
-        received.push(data)
-      },
-    },
-  } as any)
-  return received
-}
-
-describe('InMemoryQueueService payload isolation', () => {
-  test('a job carries the payload as it was when added', async () => {
-    const received = registerRecordingWorker('mutated')
-    const queue = new InMemoryQueueService()
-    const payload = { items: ['a'] }
-
-    await queue.add('mutated', payload, { delay: 0 })
-    payload.items.push('b')
-
-    assert.equal(await waitUntil(() => received.length === 1), true)
-    assert.deepEqual(
-      received[0].items,
-      ['a'],
-      'the worker saw a mutation made after the job was queued — a real queue would have serialised it away'
-    )
-  })
-
-  test('a payload arrives shaped the way a real queue would deliver it', async () => {
-    const received = registerRecordingWorker('serialised')
-    const queue = new InMemoryQueueService()
-
-    await queue.add(
-      'serialised',
-      { when: new Date('2020-01-01T00:00:00.000Z') },
-      { delay: 0 }
-    )
-
-    assert.equal(await waitUntil(() => received.length === 1), true)
-    assert.equal(
-      received[0].when,
-      '2020-01-01T00:00:00.000Z',
-      'a Date survived as a Date, so dev behaviour diverges from every real queue backend'
-    )
-  })
-})
-
-describe('InMemoryQueueService retry', () => {
-  test('redelivers a transiently-failing job until it succeeds', async () => {
-    const calls = registerWorker('flaky', (count) => {
-      if (count <= 2) throw new Error(`transient ${count}`)
-    })
-    const queue = new InMemoryQueueService()
-
-    await queue.add('flaky', {}, { attempts: 5, delay: 0 })
-
-    // Succeeds on the 3rd attempt; must not exceed the configured attempts.
-    assert.equal(await waitUntil(() => calls.count >= 3), true)
-    await new Promise((r) => setTimeout(r, 150))
-    assert.equal(calls.count, 3, 'should stop retrying once the job succeeds')
-  })
-
-  test('stops after `attempts` when a job always fails', async () => {
-    const calls = registerWorker('always-fails', () => {
-      throw new Error('boom')
-    })
-    const queue = new InMemoryQueueService()
-
-    await queue.add('always-fails', {}, { attempts: 3, delay: 0 })
-
-    assert.equal(await waitUntil(() => calls.count >= 3), true)
-    await new Promise((r) => setTimeout(r, 150))
-    assert.equal(calls.count, 3, 'must not redeliver beyond `attempts`')
-  })
-
-  test('runs once and does not retry when no attempts are configured', async () => {
-    const calls = registerWorker('no-retry', () => {
-      throw new Error('boom')
-    })
-    const queue = new InMemoryQueueService()
-
-    await queue.add('no-retry', {}, { delay: 0 })
-
-    await new Promise((r) => setTimeout(r, 150))
-    assert.equal(calls.count, 1, 'a job without attempts runs exactly once')
-  })
-})

package/src/services/in-memory-queue-service.ts

@@ -1,78 +0,0 @@
-import type {
-  QueueService,
-  QueueJob,
-  JobOptions,
-} from '../wirings/queue/queue.types.js'
-import { runQueueJob } from '../wirings/queue/queue-runner.js'
-
-// knowledge: decisions/internals/the-dev-queue-copies-prod-timing-and-serialization-semantics.md
-export class InMemoryQueueService implements QueueService {
-  readonly supportsResults = false
-  private jobCounter = 0
-
-  async add<T>(
-    queueName: string,
-    data: T,
-    options?: JobOptions
-  ): Promise<string> {
-    const jobId = `inmem-${++this.jobCounter}`
-    const maxAttempts = Math.max(1, options?.attempts ?? 1)
-    let attemptsMade = 0
-    const createdAt = new Date()
-    const payload: T =
-      data === undefined ? data : (JSON.parse(JSON.stringify(data)) as T)
-
-    const runAttempt = async () => {
-      attemptsMade++
-      const job: QueueJob<T> = {
-        id: jobId,
-        queueName,
-        data: payload,
-        status: () => 'active',
-        metadata: () => ({ attemptsMade, maxAttempts, createdAt }),
-        pikkuUserId: options?.pikkuUserId,
-      }
-      try {
-        await runQueueJob({ job })
-      } catch (e: any) {
-        if (attemptsMade < maxAttempts) {
-          setTimeout(
-            runAttempt,
-            this.backoffDelay(options?.backoff, attemptsMade)
-          )
-        } else {
-          console.error(
-            `[InMemoryQueue] Job ${jobId} on ${queueName} failed after ${attemptsMade} attempt(s):`,
-            e.message
-          )
-        }
-      }
-    }
-
-    const delay = options?.delay ?? 100 + Math.floor(Math.random() * 201)
-    setTimeout(runAttempt, delay)
-
-    return jobId
-  }
-
-  private backoffDelay(
-    backoff: JobOptions['backoff'],
-    attemptsMade: number
-  ): number {
-    const baseDelay = typeof backoff === 'object' ? (backoff.delay ?? 50) : 50
-    if (
-      backoff === 'exponential' ||
-      (typeof backoff === 'object' && backoff?.type === 'exponential')
-    ) {
-      return Math.min(2 ** (attemptsMade - 1) * baseDelay, 2000)
-    }
-    if (typeof backoff === 'object' && backoff?.type === 'fixed') {
-      return backoff.delay ?? 50
-    }
-    return 50
-  }
-
-  async getJob(): Promise<null> {
-    return null
-  }
-}

package/src/services/in-memory-session-store.test.ts

@@ -1,58 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { InMemorySessionStore } from './in-memory-session-store.js'
-
-describe('InMemorySessionStore', () => {
-  test('get returns undefined for unknown user', async () => {
-    const store = new InMemorySessionStore()
-    const result = await store.get('unknown')
-    assert.equal(result, undefined)
-  })
-
-  test('set and get round-trip', async () => {
-    const store = new InMemorySessionStore()
-    const session = { userId: 'user-1', organizationId: 'org-1' } as any
-    await store.set('user-1', session)
-
-    const result = await store.get('user-1')
-    assert.deepEqual(result, session)
-  })
-
-  test('set overwrites previous session', async () => {
-    const store = new InMemorySessionStore()
-    await store.set('user-1', { userId: 'user-1', role: 'admin' } as any)
-    await store.set('user-1', { userId: 'user-1', role: 'member' } as any)
-
-    const result = await store.get('user-1')
-    assert.deepEqual(result, { userId: 'user-1', role: 'member' })
-  })
-
-  test('clear removes session', async () => {
-    const store = new InMemorySessionStore()
-    await store.set('user-1', { userId: 'user-1' } as any)
-    assert.ok(await store.get('user-1'))
-
-    await store.clear('user-1')
-    const result = await store.get('user-1')
-    assert.equal(result, undefined)
-  })
-
-  test('clear is no-op for unknown user', async () => {
-    const store = new InMemorySessionStore()
-    await store.clear('nonexistent')
-  })
-
-  test('users are isolated', async () => {
-    const store = new InMemorySessionStore()
-    await store.set('user-a', { userId: 'a' } as any)
-    await store.set('user-b', { userId: 'b' } as any)
-
-    assert.deepEqual(await store.get('user-a'), { userId: 'a' })
-    assert.deepEqual(await store.get('user-b'), { userId: 'b' })
-
-    await store.clear('user-a')
-    assert.equal(await store.get('user-a'), undefined)
-    assert.deepEqual(await store.get('user-b'), { userId: 'b' })
-  })
-})

package/src/services/in-memory-session-store.ts

@@ -1,20 +0,0 @@
-import type { CoreUserSession } from '../types/core.types.js'
-import type { SessionStore } from './session-store.js'
-
-export class InMemorySessionStore<
-  UserSession extends CoreUserSession = CoreUserSession,
-> implements SessionStore<UserSession> {
-  private sessions = new Map<string, UserSession>()
-
-  async get(pikkuUserId: string): Promise<UserSession | undefined> {
-    return this.sessions.get(pikkuUserId)
-  }
-
-  async set(pikkuUserId: string, session: UserSession): Promise<void> {
-    this.sessions.set(pikkuUserId, session)
-  }
-
-  async clear(pikkuUserId: string): Promise<void> {
-    this.sessions.delete(pikkuUserId)
-  }
-}

package/src/services/in-memory-trigger-service.ts

@@ -1,47 +0,0 @@
-import { PikkuTriggerService } from '../wirings/trigger/pikku-trigger-service.js'
-import { getSingletonServices } from '../pikku-state.js'
-
-// knowledge: decisions/internals/local-trigger-and-gateway-services-assume-a-single-process.md
-export class InMemoryTriggerService extends PikkuTriggerService {
-  async start(): Promise<void> {
-    const singletonServices = getSingletonServices()
-
-    const triggerTargets = this.getTriggerTargets()
-    const triggerSources = this.getTriggerSources()
-
-    for (const [name, source] of triggerSources) {
-      if (this.activeTriggers.has(name)) {
-        continue
-      }
-
-      const targets = triggerTargets.get(name)
-      if (!targets || targets.length === 0) {
-        singletonServices.logger.info(
-          `Trigger source '${name}' has no targets, skipping`
-        )
-        continue
-      }
-
-      try {
-        const triggerInstance = await this.setupTriggerInstance(
-          name,
-          source.input,
-          (data) => this.onTriggerFire(name, targets, data)
-        )
-
-        this.activeTriggers.set(name, triggerInstance)
-        singletonServices.logger.info(`Started trigger: ${name}`)
-      } catch (error) {
-        singletonServices.logger.error(
-          `Failed to start trigger ${name}: ${error}`
-        )
-      }
-    }
-
-    if (this.activeTriggers.size === 0) {
-      singletonServices.logger.info(
-        'No triggers started (no matching sources and targets found)'
-      )
-    }
-  }
-}