@pikku/core 0.12.2 → 0.12.4

package/src/utils.test.ts

@@ -1,350 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert'
-import {
-  closeWireServices,
-  createWeakUID,
-  isSerializable,
-  getTagGroups,
-  freezeDedupe,
-  stopSingletonServices,
-} from './utils.js'
-import {
-  resetPikkuState,
-  pikkuState,
-  initializePikkuState,
-} from './pikku-state.js'
-
-beforeEach(() => {
-  resetPikkuState()
-})
-
-describe('createWeakUID', () => {
-  test('should return a string', () => {
-    const uid = createWeakUID()
-    assert.strictEqual(typeof uid, 'string')
-  })
-
-  test('should return unique values', () => {
-    const uid1 = createWeakUID()
-    const uid2 = createWeakUID()
-    assert.notStrictEqual(uid1, uid2)
-  })
-
-  test('should contain a dash separator', () => {
-    const uid = createWeakUID()
-    assert.ok(uid.includes('-'))
-  })
-})
-
-describe('isSerializable', () => {
-  test('should return true for objects', () => {
-    assert.strictEqual(isSerializable({ key: 'value' }), true)
-  })
-
-  test('should return true for arrays', () => {
-    assert.strictEqual(isSerializable([1, 2, 3]), true)
-  })
-
-  test('should return true for numbers', () => {
-    assert.strictEqual(isSerializable(42), true)
-  })
-
-  test('should return true for booleans', () => {
-    assert.strictEqual(isSerializable(true), true)
-  })
-
-  test('should return true for null', () => {
-    assert.strictEqual(isSerializable(null), true)
-  })
-
-  test('should return false for strings', () => {
-    assert.strictEqual(isSerializable('hello'), false)
-  })
-
-  test('should return false for ArrayBuffer', () => {
-    assert.strictEqual(isSerializable(new ArrayBuffer(8)), false)
-  })
-
-  test('should return false for Uint8Array', () => {
-    assert.strictEqual(isSerializable(new Uint8Array(8)), false)
-  })
-
-  test('should return false for Int8Array', () => {
-    assert.strictEqual(isSerializable(new Int8Array(8)), false)
-  })
-
-  test('should return false for Uint16Array', () => {
-    assert.strictEqual(isSerializable(new Uint16Array(8)), false)
-  })
-
-  test('should return false for Float64Array', () => {
-    assert.strictEqual(isSerializable(new Float64Array(8)), false)
-  })
-})
-
-describe('getTagGroups', () => {
-  test('should return exact match', () => {
-    const groups = { billing: 'billing-middleware' as any }
-    const result = getTagGroups(groups, 'billing')
-    assert.deepStrictEqual(result, ['billing-middleware'])
-  })
-
-  test('should return parent tag for namespaced tag', () => {
-    const groups = { billing: 'billing-middleware' as any }
-    const result = getTagGroups(groups, 'billing:read')
-    assert.deepStrictEqual(result, ['billing-middleware'])
-  })
-
-  test('should return both exact and parent matches', () => {
-    const groups = {
-      billing: 'billing-middleware' as any,
-      'billing:read': 'billing-read-middleware' as any,
-    }
-    const result = getTagGroups(groups, 'billing:read')
-    assert.deepStrictEqual(result, [
-      'billing-read-middleware',
-      'billing-middleware',
-    ])
-  })
-
-  test('should resolve multi-level namespace', () => {
-    const groups = {
-      billing: 'b' as any,
-      'billing:read': 'br' as any,
-      'billing:read:admin': 'bra' as any,
-    }
-    const result = getTagGroups(groups, 'billing:read:admin')
-    assert.deepStrictEqual(result, ['bra', 'br', 'b'])
-  })
-
-  test('should return empty array for unmatched tag', () => {
-    const groups = { billing: 'b' as any }
-    const result = getTagGroups(groups, 'other')
-    assert.deepStrictEqual(result, [])
-  })
-
-  test('should skip missing intermediate groups', () => {
-    const groups = {
-      billing: 'b' as any,
-      // no billing:read
-      'billing:read:admin': 'bra' as any,
-    }
-    const result = getTagGroups(groups, 'billing:read:admin')
-    assert.deepStrictEqual(result, ['bra', 'b'])
-  })
-})
-
-describe('freezeDedupe', () => {
-  test('should return frozen empty array for undefined', () => {
-    const result = freezeDedupe(undefined)
-    assert.strictEqual(result.length, 0)
-    assert.ok(Object.isFrozen(result))
-  })
-
-  test('should return frozen empty array for empty array', () => {
-    const result = freezeDedupe([])
-    assert.strictEqual(result.length, 0)
-    assert.ok(Object.isFrozen(result))
-  })
-
-  test('should return same frozen reference for empty arrays', () => {
-    const result1 = freezeDedupe([])
-    const result2 = freezeDedupe(undefined)
-    assert.strictEqual(result1, result2)
-  })
-
-  test('should return frozen single element array', () => {
-    const result = freezeDedupe(['a'])
-    assert.deepStrictEqual([...result], ['a'])
-    assert.ok(Object.isFrozen(result))
-  })
-
-  test('should deduplicate array', () => {
-    const a = () => {}
-    const b = () => {}
-    const result = freezeDedupe([a, b, a, b])
-    assert.strictEqual(result.length, 2)
-    assert.strictEqual(result[0], a)
-    assert.strictEqual(result[1], b)
-  })
-
-  test('should freeze the result', () => {
-    const result = freezeDedupe([1, 2, 3])
-    assert.ok(Object.isFrozen(result))
-  })
-
-  test('should preserve order (first occurrence)', () => {
-    const result = freezeDedupe([3, 1, 2, 1, 3])
-    assert.deepStrictEqual([...result], [3, 1, 2])
-  })
-})
-
-describe('closeWireServices', () => {
-  test('should call close on services that have it', async () => {
-    let closeCalled = false
-    const mockLogger = {
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    }
-    const wireServices = {
-      serviceA: {
-        close: async () => {
-          closeCalled = true
-        },
-      },
-      serviceB: {},
-    }
-
-    await closeWireServices(mockLogger as any, wireServices as any)
-
-    assert.strictEqual(closeCalled, true)
-  })
-
-  test('should handle errors during close gracefully', async () => {
-    let errorLogged = false
-    const mockLogger = {
-      info: () => {},
-      warn: () => {},
-      error: () => {
-        errorLogged = true
-      },
-      debug: () => {},
-    }
-    const wireServices = {
-      serviceA: {
-        close: async () => {
-          throw new Error('close failed')
-        },
-      },
-    }
-
-    await closeWireServices(mockLogger as any, wireServices as any)
-
-    assert.strictEqual(errorLogged, true)
-  })
-
-  test('should skip services without close method', async () => {
-    const mockLogger = {
-      info: () => {},
-      warn: () => {},
-      error: () => {},
-      debug: () => {},
-    }
-    const wireServices = {
-      serviceA: { doStuff: () => {} },
-      serviceB: null,
-    }
-
-    await closeWireServices(mockLogger as any, wireServices as any)
-    // Should not throw
-  })
-})
-
-describe('stopSingletonServices', () => {
-  test('should stop addon services first, then parent services', async () => {
-    const order: string[] = []
-    const mockServices = {
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {},
-        debug: () => {},
-      },
-      serviceA: {
-        stop: async () => {
-          order.push('parent-serviceA')
-        },
-      },
-    }
-    pikkuState(null, 'package', 'singletonServices', mockServices as any)
-
-    initializePikkuState('@addon/pkg')
-    const addonServices = {
-      addonService: {
-        stop: async () => {
-          order.push('addon-addonService')
-        },
-      },
-    }
-    pikkuState(
-      '@addon/pkg',
-      'package',
-      'singletonServices',
-      addonServices as any
-    )
-
-    await stopSingletonServices()
-
-    assert.ok(
-      order.indexOf('addon-addonService') < order.indexOf('parent-serviceA')
-    )
-  })
-
-  test('should handle services without stop method', async () => {
-    const mockServices = {
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {},
-        debug: () => {},
-      },
-      noStop: {},
-    }
-    pikkuState(null, 'package', 'singletonServices', mockServices as any)
-
-    await stopSingletonServices()
-    // Should not throw
-  })
-
-  test('should handle errors during stop gracefully', async () => {
-    let errorLogged = false
-    const mockServices = {
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {
-          errorLogged = true
-        },
-        debug: () => {},
-      },
-      failing: {
-        stop: async () => {
-          throw new Error('stop failed')
-        },
-      },
-    }
-    pikkuState(null, 'package', 'singletonServices', mockServices as any)
-
-    await stopSingletonServices()
-
-    assert.strictEqual(errorLogged, true)
-  })
-
-  test('should clear addon singleton services after stopping', async () => {
-    const mockServices = {
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {},
-        debug: () => {},
-      },
-    }
-    pikkuState(null, 'package', 'singletonServices', mockServices as any)
-
-    initializePikkuState('@addon/pkg')
-    pikkuState('@addon/pkg', 'package', 'singletonServices', {
-      s: { stop: async () => {} },
-    } as any)
-
-    await stopSingletonServices()
-
-    const addonServices = pikkuState(
-      '@addon/pkg',
-      'package',
-      'singletonServices'
-    )
-    assert.strictEqual(addonServices, null)
-  })
-})

package/src/utils.ts

@@ -1,129 +0,0 @@
-import type { Logger } from './services/logger.js'
-import type { WireServices } from './types/core.types.js'
-import { getSingletonServices, getAllPackageStates } from './pikku-state.js'
-
-export const closeWireServices = async (
-  logger: Logger,
-  wireServices: WireServices
-) => {
-  await Promise.all(
-    Object.values(wireServices).map(async (service: any) => {
-      if (service?.close) {
-        try {
-          await service.close()
-        } catch (e: any) {
-          logger.error(e)
-        }
-      }
-    })
-  )
-}
-
-const _uidPrefix = Date.now().toString(36)
-let _uidCounter = 0
-export const createWeakUID = () => `${_uidPrefix}-${++_uidCounter}`
-
-export const isSerializable = (data: any): boolean => {
-  return !(
-    typeof data === 'string' ||
-    data instanceof ArrayBuffer ||
-    data instanceof Uint8Array ||
-    data instanceof Int8Array ||
-    data instanceof Uint16Array ||
-    data instanceof Int16Array ||
-    data instanceof Uint32Array ||
-    data instanceof Int32Array ||
-    data instanceof Float32Array ||
-    data instanceof Float64Array
-  )
-}
-
-export const getTagGroups = <T>(
-  tagGroups: Record<string, T>,
-  tag: string
-): T[] => {
-  const results: T[] = []
-  const exact = tagGroups[tag]
-  if (exact) results.push(exact)
-  let colonIdx = tag.lastIndexOf(':')
-  while (colonIdx !== -1) {
-    const parent = tag.slice(0, colonIdx)
-    const group = tagGroups[parent]
-    if (group) results.push(group)
-    colonIdx = parent.lastIndexOf(':')
-  }
-  return results
-}
-
-const EMPTY_ARRAY = Object.freeze([])
-
-export const freezeDedupe = <T>(
-  arr?: readonly T[] | T[] | undefined
-): readonly T[] => {
-  if (!arr || arr.length === 0) return EMPTY_ARRAY
-  if (arr.length === 1) return Object.freeze([arr[0]!])
-  const seen = new Set<T>()
-  const out: T[] = []
-  for (let i = 0; i < arr.length; i++) {
-    const fn = arr[i]!
-    if (!seen.has(fn)) {
-      seen.add(fn)
-      out.push(fn)
-    }
-  }
-  return Object.freeze(out)
-}
-
-/**
- * Stop a single service by calling its stop method if it exists
- */
-const stopService = async (
-  logger: Logger,
-  name: string,
-  service: any
-): Promise<void> => {
-  const stop = service?.stop
-  if (stop) {
-    logger.info(`Stopping singleton service: ${name}`)
-    try {
-      await stop.call(service)
-    } catch (e: any) {
-      logger.error(`Error stopping service ${name}:`, e)
-    }
-  }
-}
-
-/**
- * Stop all singleton services, including addon package services.
- * Addon package services are stopped first, then the parent services.
- *
- * @param singletonServices - The parent singleton services to stop
- */
-export const stopSingletonServices = async (): Promise<void> => {
-  const singletonServices = getSingletonServices()
-  const logger = singletonServices.logger
-
-  // Stop all addon package singleton services
-  const stateMap = getAllPackageStates()
-  if (stateMap.size > 0) {
-    for (const [packageName, packageState] of stateMap) {
-      // Skip main package - we handle it separately
-      if (packageName === '__main__') continue
-
-      const packageServices = packageState.package?.singletonServices
-      if (packageServices) {
-        logger.info(`Stopping singleton services for package: ${packageName}`)
-        for (const [name, service] of Object.entries(packageServices)) {
-          await stopService(logger, `${packageName}/${name}`, service)
-        }
-        // Clear the cached services
-        packageState.package.singletonServices = null
-      }
-    }
-  }
-
-  // Then stop the parent singleton services
-  for (const [name, service] of Object.entries(singletonServices)) {
-    await stopService(logger, name, service)
-  }
-}

package/src/version.test.ts

@@ -1,80 +0,0 @@
-import { strict as assert } from 'assert'
-import { describe, test } from 'node:test'
-import {
-  formatVersionedId,
-  parseVersionedId,
-  isVersionedId,
-} from './version.js'
-
-describe('formatVersionedId', () => {
-  test('formats base name with version', () => {
-    assert.strictEqual(formatVersionedId('createUser', 1), 'createUser@v1')
-    assert.strictEqual(formatVersionedId('createUser', 2), 'createUser@v2')
-    assert.strictEqual(formatVersionedId('createUser', 10), 'createUser@v10')
-  })
-
-  test('handles namespaced base names', () => {
-    assert.strictEqual(
-      formatVersionedId('pkg:createUser', 3),
-      'pkg:createUser@v3'
-    )
-  })
-})
-
-describe('parseVersionedId', () => {
-  test('parses versioned IDs', () => {
-    assert.deepStrictEqual(parseVersionedId('createUser@v1'), {
-      baseName: 'createUser',
-      version: 1,
-    })
-    assert.deepStrictEqual(parseVersionedId('createUser@v2'), {
-      baseName: 'createUser',
-      version: 2,
-    })
-    assert.deepStrictEqual(parseVersionedId('createUser@v10'), {
-      baseName: 'createUser',
-      version: 10,
-    })
-  })
-
-  test('returns null version for unversioned IDs', () => {
-    assert.deepStrictEqual(parseVersionedId('createUser'), {
-      baseName: 'createUser',
-      version: null,
-    })
-  })
-
-  test('returns null version for invalid version suffix', () => {
-    assert.deepStrictEqual(parseVersionedId('createUser@vx'), {
-      baseName: 'createUser@vx',
-      version: null,
-    })
-    assert.deepStrictEqual(parseVersionedId('createUser@v0'), {
-      baseName: 'createUser@v0',
-      version: null,
-    })
-    assert.deepStrictEqual(parseVersionedId('createUser@v-1'), {
-      baseName: 'createUser@v-1',
-      version: null,
-    })
-  })
-
-  test('handles namespaced versioned IDs', () => {
-    assert.deepStrictEqual(parseVersionedId('pkg:createUser@v3'), {
-      baseName: 'pkg:createUser',
-      version: 3,
-    })
-  })
-})
-
-describe('isVersionedId', () => {
-  test('returns true for versioned IDs', () => {
-    assert.strictEqual(isVersionedId('createUser@v1'), true)
-    assert.strictEqual(isVersionedId('createUser@v99'), true)
-  })
-
-  test('returns false for unversioned IDs', () => {
-    assert.strictEqual(isVersionedId('createUser'), false)
-    assert.strictEqual(isVersionedId('createUser@vx'), false)
-  })
-})

package/src/version.ts

@@ -1,25 +0,0 @@
-const VERSION_SEPARATOR = '@v'
-
-export function formatVersionedId(baseName: string, version: number): string {
-  return `${baseName}${VERSION_SEPARATOR}${version}`
-}
-
-export function parseVersionedId(id: string): {
-  baseName: string
-  version: number | null
-} {
-  const idx = id.lastIndexOf(VERSION_SEPARATOR)
-  if (idx === -1) {
-    return { baseName: id, version: null }
-  }
-  const versionStr = id.slice(idx + VERSION_SEPARATOR.length)
-  const version = Number(versionStr)
-  if (!Number.isInteger(version) || version < 1) {
-    return { baseName: id, version: null }
-  }
-  return { baseName: id.slice(0, idx), version }
-}
-
-export function isVersionedId(id: string): boolean {
-  return parseVersionedId(id).version !== null
-}