@pikku/core 0.12.107 → 0.12.111

package/src/services/local-secrets.ts

@@ -1,71 +0,0 @@
-import {
-  createSecretValue,
-  isSecretValue,
-  type SecretValue,
-} from '../classification/secret-value.js'
-import { LocalVariablesService } from './local-variables.js'
-import type { SecretService, SecretValues } from './secret-service.js'
-import type { VariablesService } from './variables-service.js'
-
-export class LocalSecretService implements SecretService {
-  private localSecrets: Map<string, string> = new Map()
-
-  private parseSecret<T>(raw: string): T {
-    try {
-      return JSON.parse(raw) as T
-    } catch {
-      return raw as unknown as T
-    }
-  }
-
-  constructor(
-    private variables: VariablesService = new LocalVariablesService()
-  ) {}
-
-  public async getSecret<T = string>(key: string): Promise<SecretValue<T>> {
-    const localValue = this.localSecrets.get(key)
-    if (localValue) {
-      return createSecretValue(this.parseSecret<T>(localValue))
-    }
-
-    const value = await this.variables.get(key)
-    if (value) {
-      return createSecretValue(this.parseSecret<T>(value))
-    }
-    throw new Error(`Requested secret not found: ${key}`)
-  }
-
-  public async setSecret(key: string, value: unknown): Promise<void> {
-    // Storing the wrapper would serialize it to '[secret]', so unwrap first —
-    // writing a secret back to the vault is exactly what this method is for.
-    const raw = isSecretValue(value) ? value.reveal() : value
-    this.localSecrets.set(
-      key,
-      typeof raw === 'string' ? raw : JSON.stringify(raw)
-    )
-  }
-
-  public async hasSecret(key: string): Promise<boolean> {
-    if (this.localSecrets.has(key)) {
-      return true
-    }
-    const value = await this.variables.get(key)
-    return value !== undefined && value !== null && value !== ''
-  }
-
-  public async deleteSecret(key: string): Promise<void> {
-    this.localSecrets.delete(key)
-  }
-
-  public async getSecrets<
-    T extends Record<string, unknown> = Record<string, unknown>,
-  >(keys: (keyof T & string)[]): Promise<Partial<SecretValues<T>>> {
-    const results = await Promise.allSettled(keys.map((k) => this.getSecret(k)))
-    const out: Record<string, unknown> = {}
-    keys.forEach((key, i) => {
-      if (results[i].status === 'fulfilled')
-        out[key] = (results[i] as PromiseFulfilledResult<unknown>).value
-    })
-    return out as Partial<SecretValues<T>>
-  }
-}

package/src/services/local-variables.test.ts

@@ -1,61 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { LocalVariablesService } from './local-variables.js'
-
-describe('LocalVariablesService', () => {
-  test('should get a variable', () => {
-    const service = new LocalVariablesService({ MY_VAR: 'hello' })
-    assert.strictEqual(service.get('MY_VAR'), 'hello')
-  })
-
-  test('should return undefined for missing variable', () => {
-    const service = new LocalVariablesService({})
-    assert.strictEqual(service.get('MISSING'), undefined)
-  })
-
-  test('should set a variable', () => {
-    const service = new LocalVariablesService({})
-    service.set('KEY', 'value')
-    assert.strictEqual(service.get('KEY'), 'value')
-  })
-
-  test('should delete a variable', () => {
-    const service = new LocalVariablesService({ KEY: 'val' })
-    service.delete('KEY')
-    assert.strictEqual(service.get('KEY'), undefined)
-  })
-
-  test('should check if variable exists', () => {
-    const service = new LocalVariablesService({ KEY: 'val' })
-    assert.strictEqual(service.has('KEY'), true)
-    assert.strictEqual(service.has('MISSING'), false)
-  })
-
-  test('should get all variables', () => {
-    const vars = { A: '1', B: '2' }
-    const service = new LocalVariablesService(vars)
-    assert.deepStrictEqual(service.getAll(), vars)
-  })
-
-  test('should get JSON variable', () => {
-    const service = new LocalVariablesService({ DATA: '{"key":"val"}' })
-    const result = service.get('DATA')
-    assert.deepStrictEqual(result, { key: 'val' })
-  })
-
-  test('should return undefined for missing JSON variable', () => {
-    const service = new LocalVariablesService({})
-    assert.strictEqual(service.get('MISSING'), undefined)
-  })
-
-  test('should set JSON variable', () => {
-    const service = new LocalVariablesService({})
-    service.set('DATA', { key: 'val' })
-    assert.deepStrictEqual(service.get('DATA'), { key: 'val' })
-  })
-
-  test('should handle has with undefined value', () => {
-    const service = new LocalVariablesService({ KEY: undefined })
-    assert.strictEqual(service.has('KEY'), false)
-  })
-})

package/src/services/local-variables.ts

@@ -1,45 +0,0 @@
-import type { VariablesService } from './variables-service.js'
-
-export class LocalVariablesService implements VariablesService {
-  constructor(
-    private variables: Record<string, string | undefined> = process.env
-  ) {}
-
-  public getAll(): Record<string, string | undefined> {
-    return this.variables || {}
-  }
-
-  public getVariables<
-    T extends Record<string, unknown> = Record<string, unknown>,
-  >(names: (keyof T & string)[]): Partial<T> {
-    const out: Record<string, unknown> = {}
-    for (const name of names) {
-      const value = this.get(name)
-      if (value !== undefined) out[name] = value
-    }
-    return out as Partial<T>
-  }
-
-  public get<T = string>(name: string): T | undefined {
-    const raw = this.variables[name]
-    if (raw === undefined) return undefined
-    try {
-      return JSON.parse(raw) as T
-    } catch {
-      return raw as unknown as T
-    }
-  }
-
-  public set(name: string, value: unknown): void {
-    this.variables[name] =
-      typeof value === 'string' ? value : JSON.stringify(value)
-  }
-
-  public has(name: string): boolean {
-    return name in this.variables && this.variables[name] !== undefined
-  }
-
-  public delete(name: string): void {
-    delete this.variables[name]
-  }
-}

package/src/services/logger-console.test.ts

@@ -1,117 +0,0 @@
-import { describe, test, beforeEach } from 'node:test'
-import assert from 'node:assert'
-import { ConsoleLogger } from './logger-console.js'
-import { LogLevel } from './logger.js'
-
-describe('ConsoleLogger', () => {
-  let logger: ConsoleLogger
-  let captured: { method: string; args: any[] }[]
-  let origConsole: Record<string, any>
-
-  beforeEach(() => {
-    logger = new ConsoleLogger()
-    captured = []
-    origConsole = {
-      trace: console.trace,
-      debug: console.debug,
-      info: console.info,
-      warn: console.warn,
-      error: console.error,
-      log: console.log,
-    }
-    console.trace = (...args: any[]) => captured.push({ method: 'trace', args })
-    console.debug = (...args: any[]) => captured.push({ method: 'debug', args })
-    console.info = (...args: any[]) => captured.push({ method: 'info', args })
-    console.warn = (...args: any[]) => captured.push({ method: 'warn', args })
-    console.error = (...args: any[]) => captured.push({ method: 'error', args })
-    console.log = (...args: any[]) => captured.push({ method: 'log', args })
-  })
-
-  test('should log info at default level', () => {
-    logger.info('test message')
-    assert.strictEqual(captured.length, 1)
-    assert.strictEqual(captured[0].method, 'info')
-    assert.ok(captured[0].args.includes('test message'))
-    Object.assign(console, origConsole)
-  })
-
-  test('should not log debug at default info level', () => {
-    logger.debug('debug message')
-    assert.strictEqual(captured.length, 0)
-    Object.assign(console, origConsole)
-  })
-
-  test('should log debug when level is set to debug', () => {
-    logger.setLevel(LogLevel.debug)
-    logger.debug('debug message')
-    assert.strictEqual(captured.length, 1)
-    assert.strictEqual(captured[0].method, 'debug')
-    Object.assign(console, origConsole)
-  })
-
-  test('should log warn at info level', () => {
-    logger.warn('warning')
-    assert.strictEqual(captured.length, 1)
-    assert.strictEqual(captured[0].method, 'warn')
-    Object.assign(console, origConsole)
-  })
-
-  test('should log error at info level', () => {
-    logger.error('error message')
-    assert.strictEqual(captured.length, 1)
-    assert.strictEqual(captured[0].method, 'error')
-    Object.assign(console, origConsole)
-  })
-
-  test('should log Error instance with stack trace', () => {
-    const err = new Error('test error')
-    logger.error(err)
-    assert.strictEqual(captured.length, 2) // error message + stack
-    assert.ok(captured[0].args.includes('test error'))
-    assert.strictEqual(captured[1].args[0], 'STACK:')
-    Object.assign(console, origConsole)
-  })
-
-  test('should not log info when level is error', () => {
-    logger.setLevel(LogLevel.error)
-    logger.info('info')
-    logger.warn('warn')
-    logger.debug('debug')
-    assert.strictEqual(captured.length, 0)
-    Object.assign(console, origConsole)
-  })
-
-  test('should log error when level is error', () => {
-    logger.setLevel(LogLevel.error)
-    logger.error('critical')
-    assert.strictEqual(captured.length, 1)
-    Object.assign(console, origConsole)
-  })
-
-  test('should support trace level when enabled', () => {
-    logger.setLevel(LogLevel.trace)
-    logger.trace!('trace message')
-    assert.strictEqual(captured.length, 1)
-    assert.strictEqual(captured[0].method, 'trace')
-    Object.assign(console, origConsole)
-  })
-
-  test('should log with additional metadata', () => {
-    logger.info('message', { extra: 'data' })
-    assert.ok(captured[0].args.includes('message'))
-    Object.assign(console, origConsole)
-  })
-
-  test('should handle object messages in info', () => {
-    logger.info({ key: 'value' })
-    assert.strictEqual(captured.length, 1)
-    Object.assign(console, origConsole)
-  })
-
-  test('log method should respect level', () => {
-    logger.setLevel(LogLevel.error)
-    logger.log('info', 'should not show')
-    assert.strictEqual(captured.length, 0)
-    Object.assign(console, origConsole)
-  })
-})

package/src/services/logger-console.ts

@@ -1,174 +0,0 @@
-import type { Logger } from './logger.js'
-import { LogLevel } from './logger.js'
-
-/** Emits `INFO: message`, or `[traceId] INFO: message` when scoped. */
-export class ConsoleLogger implements Logger {
-  private level: LogLevel = LogLevel.info
-  private prefix: string
-
-  constructor(traceId?: string) {
-    this.prefix = traceId ? `[${traceId}]` : ''
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  scope(traceId: string): Logger {
-    const scoped = new ConsoleLogger(traceId)
-    scoped.level = this.level
-    return scoped
-  }
-
-  private log_(
-    fn: (...args: unknown[]) => void,
-    label: string,
-    ...args: unknown[]
-  ): void {
-    if (this.prefix) {
-      fn(this.prefix, label, ...args)
-    } else {
-      fn(label, ...args)
-    }
-  }
-
-  trace(message: string, ...meta: any[]): void {
-    if (this.level <= LogLevel.trace) {
-      this.log_(console.trace, 'TRACE:', message, ...meta)
-    }
-  }
-
-  debug(message: string, ...meta: any[]): void {
-    if (this.level <= LogLevel.debug) {
-      this.log_(console.debug, 'DEBUG:', message, ...meta)
-    }
-  }
-
-  info(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
-    if (this.level <= LogLevel.info) {
-      this.log_(console.info, 'INFO:', messageOrObj, ...meta)
-    }
-  }
-
-  warn(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
-    if (this.level <= LogLevel.warn) {
-      this.log_(console.warn, 'WARN:', messageOrObj, ...meta)
-    }
-  }
-
-  error(
-    messageOrObj: string | Record<string, any> | Error,
-    ...meta: any[]
-  ): void {
-    if (this.level <= LogLevel.error) {
-      this.log_(
-        console.error,
-        'ERROR:',
-        messageOrObj instanceof Error ? messageOrObj.message : messageOrObj,
-        ...meta
-      )
-      if (messageOrObj instanceof Error) {
-        this.log_(console.error, 'STACK:', messageOrObj.stack)
-      }
-    }
-  }
-
-  log(level: string, message: string, ...meta: any[]): void {
-    const logLevel = LogLevel[level as keyof typeof LogLevel]
-    if (this.level <= logLevel) {
-      this.log_(console.log, `${level.toUpperCase()}:`, message, ...meta)
-    }
-  }
-}
-
-/**
- * Emits `{"level":"info","message":"...","traceId":"..."}` — one JSON object per
- * line, because Cloudflare Workers Logs auto-indexes JSON keys for filtering.
- */
-export class JsonConsoleLogger implements Logger {
-  private level: LogLevel = LogLevel.info
-  private traceId: string | undefined
-
-  constructor(traceId?: string) {
-    this.traceId = traceId
-  }
-
-  setLevel(level: LogLevel): void {
-    this.level = level
-  }
-
-  scope(traceId: string): Logger {
-    const scoped = new JsonConsoleLogger(traceId)
-    scoped.level = this.level
-    return scoped
-  }
-
-  trace(message: string, ...meta: any[]): void {
-    if (this.level <= LogLevel.trace) {
-      this.emit(console.debug, 'trace', message, meta)
-    }
-  }
-
-  debug(message: string, ...meta: any[]): void {
-    if (this.level <= LogLevel.debug) {
-      this.emit(console.debug, 'debug', message, meta)
-    }
-  }
-
-  info(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
-    if (this.level <= LogLevel.info) {
-      this.emit(console.info, 'info', messageOrObj, meta)
-    }
-  }
-
-  warn(messageOrObj: string | Record<string, any>, ...meta: any[]): void {
-    if (this.level <= LogLevel.warn) {
-      this.emit(console.warn, 'warn', messageOrObj, meta)
-    }
-  }
-
-  error(
-    messageOrObj: string | Record<string, any> | Error,
-    ...meta: any[]
-  ): void {
-    if (this.level <= LogLevel.error) {
-      if (messageOrObj instanceof Error) {
-        this.emit(console.error, 'error', messageOrObj.message, meta)
-        console.error(
-          JSON.stringify({
-            level: 'error',
-            message: 'stack',
-            stack: messageOrObj.stack,
-            ...(this.traceId ? { traceId: this.traceId } : {}),
-          })
-        )
-      } else {
-        this.emit(console.error, 'error', messageOrObj, meta)
-      }
-    }
-  }
-
-  log(level: string, message: string, ...meta: any[]): void {
-    const logLevel = LogLevel[level as keyof typeof LogLevel]
-    if (this.level <= logLevel) {
-      this.emit(console.log, level, message, meta)
-    }
-  }
-
-  private emit(
-    fn: (...args: any[]) => void,
-    level: string,
-    messageOrObj: string | Record<string, any>,
-    meta: any[]
-  ): void {
-    const entry: Record<string, unknown> = { level }
-    if (this.traceId) entry.traceId = this.traceId
-    if (typeof messageOrObj === 'string') {
-      entry.message = messageOrObj
-    } else {
-      Object.assign(entry, messageOrObj)
-    }
-    if (meta.length > 0) entry.meta = meta
-    fn(JSON.stringify(entry))
-  }
-}

package/src/services/logger.ts

@@ -1,48 +0,0 @@
-import type { Safe } from '../classification/secret-value.js'
-
-export enum LogLevel {
-  trace,
-  debug,
-  info,
-  warn,
-  error,
-  critical,
-}
-
-/**
- * A log line is the easiest place to leak a vault secret, so every parameter is
- * `Safe<>`-guarded: a `SecretValue` anywhere in the message or the metadata,
- * however deeply nested, collapses to `never` and fails the build. Reveal it
- * first if you genuinely mean to log it.
- */
-export interface Logger {
-  info<M extends string | Record<string, any>, A extends unknown[]>(
-    messageOrObj: Safe<M>,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void
-
-  warn<M extends string | Record<string, any>, A extends unknown[]>(
-    messageOrObj: Safe<M>,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void
-
-  error<M extends string | Record<string, any> | Error, A extends unknown[]>(
-    messageOrObj: Safe<M>,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void
-
-  debug<A extends unknown[]>(
-    message: string,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void
-
-  trace?<A extends unknown[]>(
-    message: string,
-    ...meta: { [K in keyof A]: Safe<A[K]> }
-  ): void
-
-  setLevel(level: LogLevel): void
-
-  /** A logger carrying a traceId on every entry, taken per-request to correlate calls. */
-  scope?(traceId: string): Logger
-}

package/src/services/meta-service.test.ts

@@ -1,75 +0,0 @@
-import { describe, test, before, after } from 'node:test'
-import assert from 'node:assert/strict'
-import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { LocalMetaService } from './meta-service.js'
-
-// knowledge: decisions/internals/scenario-meta-lives-apart-from-app-meta-but-merges-when-read-off-disk.md
-describe('LocalMetaService reads the scenario meta alongside the app meta', () => {
-  let pikkuDir: string
-
-  before(async () => {
-    pikkuDir = await mkdtemp(join(tmpdir(), 'pikku-meta-'))
-    await mkdir(join(pikkuDir, 'workflow', 'meta'), { recursive: true })
-    await mkdir(join(pikkuDir, 'scenarios', 'meta'), { recursive: true })
-    await mkdir(join(pikkuDir, 'function'), { recursive: true })
-    await mkdir(join(pikkuDir, 'scenarios'), { recursive: true })
-
-    await writeFile(
-      join(pikkuDir, 'workflow', 'meta', 'orderWorkflow.gen.json'),
-      JSON.stringify({ name: 'orderWorkflow', source: 'dsl' })
-    )
-    await writeFile(
-      join(pikkuDir, 'scenarios', 'meta', 'codeEditorScenario.gen.json'),
-      JSON.stringify({ name: 'codeEditorScenario', source: 'scenario' })
-    )
-    await writeFile(
-      join(pikkuDir, 'function', 'pikku-functions-meta.gen.json'),
-      JSON.stringify({ createTodo: { pikkuFuncId: 'createTodo' } })
-    )
-    await writeFile(
-      join(pikkuDir, 'scenarios', 'pikku-scenario-functions-meta.gen.json'),
-      JSON.stringify({
-        opensPage: { pikkuFuncId: 'opensPage', scenarioStep: true },
-      })
-    )
-  })
-
-  after(async () => {
-    await rm(pikkuDir, { recursive: true, force: true })
-  })
-
-  test('a scenario is still a workflow to whoever reads the meta', async () => {
-    const meta = await new LocalMetaService(pikkuDir).getWorkflowMeta()
-    assert.deepEqual(Object.keys(meta).sort(), [
-      'codeEditorScenario',
-      'orderWorkflow',
-    ])
-    assert.equal(meta['codeEditorScenario']!.source, 'scenario')
-  })
-
-  test('a scenario step is still a function to whoever reads the meta', async () => {
-    const meta = await new LocalMetaService(pikkuDir).getFunctionsMeta()
-    assert.deepEqual(Object.keys(meta).sort(), ['createTodo', 'opensPage'])
-    assert.equal(meta['opensPage']!.scenarioStep, true)
-  })
-
-  test('a project with no scenarios reads exactly what it has', async () => {
-    const empty = await mkdtemp(join(tmpdir(), 'pikku-meta-empty-'))
-    await mkdir(join(empty, 'workflow', 'meta'), { recursive: true })
-    await writeFile(
-      join(empty, 'workflow', 'meta', 'orderWorkflow.gen.json'),
-      JSON.stringify({ name: 'orderWorkflow', source: 'dsl' })
-    )
-
-    const service = new LocalMetaService(empty)
-    assert.deepEqual(Object.keys(await service.getWorkflowMeta()), [
-      'orderWorkflow',
-    ])
-    assert.deepEqual(Object.keys(await service.getFunctionsMeta()), [])
-
-    await rm(empty, { recursive: true, force: true })
-  })
-})