@pikku/core 0.12.107 → 0.12.112

package/src/services/local-content.ts

@@ -1,242 +0,0 @@
-import { createReadStream, createWriteStream, promises } from 'fs'
-import { mkdir, readFile } from 'fs/promises'
-import { resolve, normalize } from 'path'
-import type {
-  BucketKeyArgs,
-  ContentService,
-  CopyFileArgs,
-  GetUploadURLArgs,
-  JWTService,
-  Logger,
-  SignContentKeyArgs,
-  SignURLArgs,
-  UploadURLResult,
-  WriteFileArgs,
-} from '@pikku/core/services'
-import { pipeline } from 'stream/promises'
-import type { Readable } from 'stream'
-
-export interface LocalContentConfig {
-  localFileUploadPath: string
-  uploadUrlPrefix: string
-  assetUrlPrefix: string
-  server?: string
-  sizeLimit?: string
-}
-
-/**
- * The representation of an asset that gets bound into a signed URL's
- * signature, and that a server can reconstruct from an incoming request:
- * the decoded path, without origin or query string.
- *
- * Both sides must derive it the same way, so signer and verifier share this
- * function. Percent escapes are decoded so that a client re-encoding an
- * optional character still matches; a malformed escape is left verbatim
- * rather than throwing, which keeps both sides in agreement.
- */
-export const signedContentPath = (urlOrPath: string): string => {
-  let pathname: string
-  try {
-    pathname = new URL(urlOrPath, 'http://pikku.local').pathname
-  } catch {
-    pathname = urlOrPath
-  }
-  try {
-    return decodeURIComponent(pathname)
-  } catch {
-    return pathname
-  }
-}
-
-/** How long a presigned upload URL stays valid. Short, like an S3 PUT URL. */
-const UPLOAD_URL_TTL_MS = 15 * 60 * 1000
-
-export class LocalContent implements ContentService {
-  constructor(
-    private config: LocalContentConfig,
-    private logger: Logger,
-    private jwt: JWTService
-  ) {
-    if (!jwt) {
-      throw new Error(
-        'LocalContent requires a JWTService: without one it cannot sign asset URLs, and unsigned URLs cannot be verified.'
-      )
-    }
-  }
-
-  private safePath(bucket: string, key: string): string {
-    const base = resolve(this.config.localFileUploadPath)
-    const scoped = resolve(base, normalize(bucket))
-    const target = resolve(scoped, normalize(key))
-    if (!target.startsWith(base + '/') && target !== base) {
-      throw new Error('Invalid asset key')
-    }
-    return target
-  }
-
-  private joinKey(bucket: string, key: string): string {
-    return `${bucket}/${key}`
-  }
-
-  public async init() {}
-
-  private async signParams(
-    url: string,
-    dateLessThan: Date,
-    dateGreaterThan?: Date
-  ): Promise<string> {
-    const signedAt = Date.now()
-    const expiresAt = dateLessThan.getTime()
-    const params = new URLSearchParams({
-      signedAt: String(signedAt),
-      expiresAt: String(expiresAt),
-    })
-    if (dateGreaterThan) {
-      params.set('notBefore', String(dateGreaterThan.getTime()))
-    }
-    const expiresInSeconds = Math.max(
-      1,
-      Math.floor((expiresAt - signedAt) / 1000)
-    )
-    const payload: {
-      signedAt: number
-      expiresAt: number
-      notBefore?: number
-      path: string
-    } = {
-      signedAt,
-      expiresAt,
-      path: signedContentPath(url),
-    }
-    if (dateGreaterThan) {
-      payload.notBefore = dateGreaterThan.getTime()
-    }
-    const signature = await this.jwt.encode(
-      { value: expiresInSeconds, unit: 'second' },
-      payload
-    )
-    params.set('signature', signature)
-    return params.toString()
-  }
-
-  public async signURL(args: SignURLArgs): Promise<string> {
-    const params = await this.signParams(
-      args.url,
-      args.dateLessThan,
-      args.dateGreaterThan
-    )
-    return `${args.url}?${params}`
-  }
-
-  public async signContentKey(args: SignContentKeyArgs): Promise<string> {
-    const fullKey = this.joinKey(args.bucket, args.contentKey)
-    const base = this.config.server
-      ? `${this.config.server}${this.config.assetUrlPrefix}/${fullKey}`
-      : `${this.config.assetUrlPrefix}/${fullKey}`
-    return this.signURL({
-      url: base,
-      dateLessThan: args.dateLessThan,
-      dateGreaterThan: args.dateGreaterThan,
-    })
-  }
-
-  /**
-   * Presigned upload, mirroring the read side: the URL carries a short-lived,
-   * path-bound signature that {@link createLocalContentRequestHandler} verifies
-   * before writing. An unsigned upload URL cannot be verified, and the handler
-   * now refuses one — so this must sign, or every upload 403s.
-   */
-  public async getUploadURL(args: GetUploadURLArgs): Promise<UploadURLResult> {
-    void args.visibility
-    const fullKey = this.joinKey(args.bucket, args.fileKey)
-    this.logger.debug(`Going to upload with key: ${fullKey}`)
-    const uploadUrl = await this.signURL({
-      url: `${this.config.uploadUrlPrefix}/${fullKey}`,
-      dateLessThan: new Date(Date.now() + UPLOAD_URL_TTL_MS),
-    })
-    return {
-      uploadUrl,
-      assetKey: fullKey,
-      uploadMethod: 'PUT',
-    }
-  }
-
-  public async writeFile(args: WriteFileArgs): Promise<boolean> {
-    this.logger.debug(`Writing file: ${args.bucket}/${args.key}`)
-
-    const path = this.safePath(args.bucket, args.key)
-
-    try {
-      await this.createDirectoryForFile(path)
-      const fileStream = createWriteStream(path)
-      await pipeline(args.stream as Readable, fileStream)
-      return true
-    } catch (e) {
-      console.error(e)
-      this.logger.error(`Error writing content ${args.bucket}/${args.key}`, e)
-      return false
-    }
-  }
-
-  public async copyFile(args: CopyFileArgs): Promise<boolean> {
-    this.logger.debug(`Writing file: ${args.bucket}/${args.key}`)
-    try {
-      const path = this.safePath(args.bucket, args.key)
-      await this.createDirectoryForFile(path)
-      await promises.copyFile(args.fromAbsolutePath, path)
-      return true
-    } catch (e) {
-      console.error(e)
-      this.logger.error(`Error inserting content ${args.bucket}/${args.key}`, e)
-    }
-    return false
-  }
-
-  public async readFile(
-    args: BucketKeyArgs
-  ): Promise<ReadableStream | NodeJS.ReadableStream> {
-    this.logger.debug(`Getting key: ${args.bucket}/${args.key}`)
-
-    const filePath = this.safePath(args.bucket, args.key)
-
-    try {
-      const stream = createReadStream(filePath)
-      stream.on('error', (err) => {
-        this.logger.error(
-          `Error getting content ${args.bucket}/${args.key}`,
-          err
-        )
-      })
-
-      return stream
-    } catch (e) {
-      this.logger.error(
-        `Error setting up stream for ${args.bucket}/${args.key}`,
-        e
-      )
-      throw e
-    }
-  }
-
-  public async readFileAsBuffer(args: BucketKeyArgs): Promise<Buffer> {
-    const filePath = this.safePath(args.bucket, args.key)
-    this.logger.debug(`Reading file as buffer: ${args.bucket}/${args.key}`)
-    return readFile(filePath)
-  }
-
-  public async deleteFile(args: BucketKeyArgs): Promise<boolean> {
-    this.logger.debug(`deleting key: ${args.bucket}/${args.key}`)
-    try {
-      await promises.unlink(this.safePath(args.bucket, args.key))
-      return true
-    } catch (e: any) {
-      this.logger.error(`Error deleting content ${args.bucket}/${args.key}`, e)
-    }
-    return false
-  }
-
-  private async createDirectoryForFile(path: string): Promise<void> {
-    const dir = path.split('/').slice(0, -1).join('/')
-    await mkdir(dir, { recursive: true })
-  }
-}

package/src/services/local-credential-service.ts

@@ -1,63 +0,0 @@
-import type { CredentialService } from './credential-service.js'
-
-export class LocalCredentialService implements CredentialService {
-  private store: Map<string, unknown> = new Map()
-
-  private makeKey(name: string, userId?: string): string {
-    return userId ? `${userId}:${name}` : name
-  }
-
-  async get<T = unknown>(name: string, userId?: string): Promise<T | null> {
-    const key = this.makeKey(name, userId)
-    const value = this.store.get(key)
-    return (value as T) ?? null
-  }
-
-  async set(name: string, value: unknown, userId?: string): Promise<void> {
-    const key = this.makeKey(name, userId)
-    this.store.set(key, value)
-  }
-
-  async delete(name: string, userId?: string): Promise<void> {
-    const key = this.makeKey(name, userId)
-    this.store.delete(key)
-  }
-
-  async has(name: string, userId?: string): Promise<boolean> {
-    const key = this.makeKey(name, userId)
-    return this.store.has(key)
-  }
-
-  async getAll(userId: string): Promise<Record<string, unknown>> {
-    const prefix = `${userId}:`
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of this.store) {
-      if (key.startsWith(prefix)) {
-        result[key.slice(prefix.length)] = value
-      }
-    }
-    return result
-  }
-
-  async getUsersWithCredential(name: string): Promise<string[]> {
-    const suffix = `:${name}`
-    const users: string[] = []
-    for (const key of this.store.keys()) {
-      if (key.endsWith(suffix)) {
-        users.push(key.slice(0, -suffix.length))
-      }
-    }
-    return users
-  }
-
-  async getAllUsers(): Promise<string[]> {
-    const users = new Set<string>()
-    for (const key of this.store.keys()) {
-      const colonIndex = key.indexOf(':')
-      if (colonIndex > 0) {
-        users.add(key.slice(0, colonIndex))
-      }
-    }
-    return [...users]
-  }
-}

package/src/services/local-email-service.test.ts

@@ -1,182 +0,0 @@
-import assert from 'node:assert/strict'
-import { test } from 'node:test'
-
-import { LocalEmailService } from './local-email-service.js'
-
-test('LocalEmailService logs sent email metadata as JSON', async () => {
-  const service = new LocalEmailService()
-  const writes: string[] = []
-  const originalInfo = console.info
-  console.info = (value?: unknown) => {
-    writes.push(String(value))
-  }
-
-  try {
-    await service.send({
-      to: 'user@example.com',
-      from: 'hello@example.com',
-      subject: 'Welcome',
-      template: {
-        name: 'welcome',
-        locale: 'en',
-        data: { userName: 'Yasser' },
-      },
-    })
-  } finally {
-    console.info = originalInfo
-  }
-
-  assert.equal(writes.length, 1)
-  const payload = JSON.parse(writes[0])
-  assert.equal(payload.type, 'email')
-  assert.equal(payload.message, 'this email was sent')
-  assert.equal(payload.to, 'user@example.com')
-  assert.equal(payload.from, 'hello@example.com')
-  assert.equal(payload.subject, 'Welcome')
-  assert.deepEqual(payload.template, {
-    name: 'welcome',
-    locale: 'en',
-    data: { userName: 'Yasser' },
-  })
-})
-
-test('LocalEmailService logs htmlLength and textLength for HTML email', async () => {
-  const service = new LocalEmailService()
-  const writes: string[] = []
-  const originalInfo = console.info
-  console.info = (value?: unknown) => {
-    writes.push(String(value))
-  }
-
-  try {
-    await service.send({
-      to: 'user@example.com',
-      html: '<p>Hello</p>',
-      text: 'Hello',
-    })
-  } finally {
-    console.info = originalInfo
-  }
-
-  const payload = JSON.parse(writes[0])
-  assert.equal(payload.htmlLength, '<p>Hello</p>'.length)
-  assert.equal(payload.textLength, 'Hello'.length)
-})
-
-test('LocalEmailService logs textLength only for plain text email', async () => {
-  const service = new LocalEmailService()
-  const writes: string[] = []
-  const originalInfo = console.info
-  console.info = (value?: unknown) => {
-    writes.push(String(value))
-  }
-
-  try {
-    await service.send({
-      to: 'user@example.com',
-      text: 'Plain text body',
-    })
-  } finally {
-    console.info = originalInfo
-  }
-
-  const payload = JSON.parse(writes[0])
-  assert.equal(payload.textLength, 'Plain text body'.length)
-  assert.equal(payload.htmlLength, undefined)
-})
-
-test('LocalEmailService logs null textLength for HTML email without plain text', async () => {
-  const service = new LocalEmailService()
-  const writes: string[] = []
-  const originalInfo = console.info
-  console.info = (value?: unknown) => {
-    writes.push(String(value))
-  }
-
-  try {
-    await service.send({
-      to: 'user@example.com',
-      html: '<p>Hello</p>',
-    })
-  } finally {
-    console.info = originalInfo
-  }
-
-  const payload = JSON.parse(writes[0])
-  assert.equal(payload.htmlLength, '<p>Hello</p>'.length)
-  assert.equal(payload.textLength, null)
-})
-
-test('LocalEmailService logs attachment metadata without the content', async () => {
-  const service = new LocalEmailService()
-  const writes: string[] = []
-  const originalInfo = console.info
-  console.info = (value?: unknown) => {
-    writes.push(String(value))
-  }
-
-  try {
-    await service.send({
-      to: 'user@example.com',
-      html: '<img src="cid:logo" />',
-      attachments: [
-        {
-          filename: 'receipt.pdf',
-          content: new Uint8Array([1, 2, 3, 4]),
-          contentType: 'application/pdf',
-        },
-        {
-          filename: 'logo.png',
-          content: 'aGVsbG8=',
-          contentType: 'image/png',
-          contentId: 'logo',
-          disposition: 'inline',
-        },
-      ],
-    })
-  } finally {
-    console.info = originalInfo
-  }
-
-  const payload = JSON.parse(writes[0])
-  assert.deepEqual(payload.attachments, [
-    {
-      filename: 'receipt.pdf',
-      contentType: 'application/pdf',
-      contentId: null,
-      disposition: 'attachment',
-      contentLength: 4,
-    },
-    {
-      filename: 'logo.png',
-      contentType: 'image/png',
-      contentId: 'logo',
-      disposition: 'inline',
-      contentLength: 8,
-    },
-  ])
-  assert.equal(writes[0].includes('aGVsbG8='), false)
-})
-
-test('LocalEmailService omits attachments when there are none', async () => {
-  const service = new LocalEmailService()
-  const writes: string[] = []
-  const originalInfo = console.info
-  console.info = (value?: unknown) => {
-    writes.push(String(value))
-  }
-
-  try {
-    await service.send({ to: 'user@example.com', text: 'no files' })
-    await service.send({
-      to: 'user@example.com',
-      text: 'no files',
-      attachments: [],
-    })
-  } finally {
-    console.info = originalInfo
-  }
-
-  assert.equal(JSON.parse(writes[0]).attachments, undefined)
-  assert.equal(JSON.parse(writes[1]).attachments, undefined)
-})

package/src/services/local-email-service.ts

@@ -1,43 +0,0 @@
-import type {
-  EmailService,
-  SendEmailInput,
-  SendEmailResult,
-} from './email-service.js'
-
-export class LocalEmailService implements EmailService {
-  async send(input: SendEmailInput): Promise<SendEmailResult> {
-    const payload: Record<string, unknown> = {
-      type: 'email',
-      message: 'this email was sent',
-      to: input.to,
-      from: input.from ?? null,
-      cc: input.cc ?? null,
-      bcc: input.bcc ?? null,
-      replyTo: input.replyTo ?? null,
-      subject: input.subject ?? null,
-    }
-
-    if ('template' in input && input.template) {
-      payload.template = input.template
-    }
-    if ('html' in input && typeof input.html === 'string') {
-      payload.htmlLength = input.html.length
-      payload.textLength = input.text?.length ?? null
-    }
-    if ('text' in input && typeof input.text === 'string') {
-      payload.textLength = input.text.length
-    }
-    if (input.attachments?.length) {
-      payload.attachments = input.attachments.map((attachment) => ({
-        filename: attachment.filename,
-        contentType: attachment.contentType ?? null,
-        contentId: attachment.contentId ?? null,
-        disposition: attachment.disposition ?? 'attachment',
-        contentLength: attachment.content.length,
-      }))
-    }
-
-    console.info(JSON.stringify(payload))
-    return {}
-  }
-}

package/src/services/local-gateway-service.ts

@@ -1,51 +0,0 @@
-import type { GatewayService } from './gateway-service.js'
-import type { GatewayAdapter } from '../wirings/gateway/gateway.types.js'
-import { pikkuState, getSingletonServices } from '../pikku-state.js'
-import {
-  createListenerMessageHandler,
-  resolveGatewayAdapter,
-} from '../wirings/gateway/gateway-runner.js'
-
-// knowledge: decisions/internals/local-trigger-and-gateway-services-assume-a-single-process.md
-export class LocalGatewayService implements GatewayService {
-  private activeAdapters = new Map<string, GatewayAdapter>()
-
-  async start(): Promise<void> {
-    const singletonServices = getSingletonServices()
-    const gateways = pikkuState(null, 'gateway', 'gateways')
-
-    for (const [name, config] of gateways) {
-      if (config.type !== 'listener') continue
-      if (this.activeAdapters.has(name)) continue
-
-      const handleMessage = createListenerMessageHandler(
-        name,
-        config,
-        singletonServices
-      )
-
-      const adapter = await resolveGatewayAdapter(config, singletonServices)
-      await adapter.init(handleMessage)
-      this.activeAdapters.set(name, adapter)
-      singletonServices.logger.info(`Started listener gateway: ${name}`)
-    }
-  }
-
-  async stop(): Promise<void> {
-    for (const [name, adapter] of this.activeAdapters) {
-      try {
-        await adapter.close()
-      } catch (e: any) {
-        try {
-          getSingletonServices().logger.error(
-            `Error closing listener gateway '${name}':`,
-            e
-          )
-        } catch {
-          // The logger may already be gone during shutdown.
-        }
-      }
-    }
-    this.activeAdapters.clear()
-  }
-}

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

@@ -1,95 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert'
-import { LocalSecretService } from './local-secrets.js'
-import { LocalVariablesService } from './local-variables.js'
-
-describe('LocalSecretService', () => {
-  test('should get secret from local storage', async () => {
-    const service = new LocalSecretService()
-    await service.setSecret('MY_KEY', { token: 'abc' })
-    const result = (await service.getSecret('MY_KEY')).reveal()
-    assert.deepStrictEqual(result, { token: 'abc' })
-  })
-
-  test('should get secret from environment variables', async () => {
-    const vars = new LocalVariablesService({ MY_SECRET: 'secret-value' })
-    const service = new LocalSecretService(vars)
-    const result = (await service.getSecret('MY_SECRET')).reveal()
-    assert.strictEqual(result, 'secret-value')
-  })
-
-  test('should throw when secret not found', async () => {
-    const vars = new LocalVariablesService({})
-    const service = new LocalSecretService(vars)
-    await assert.rejects(() => service.getSecret('MISSING'), {
-      message: 'Requested secret not found: MISSING',
-    })
-  })
-
-  test('should get JSON secret from local storage', async () => {
-    const service = new LocalSecretService()
-    await service.setSecret('JSON_KEY', { data: 42 })
-    const result = (await service.getSecret('JSON_KEY')).reveal()
-    assert.deepStrictEqual(result, { data: 42 })
-  })
-
-  test('should get JSON secret from environment variables', async () => {
-    const vars = new LocalVariablesService({ CONFIG: '{"port":3000}' })
-    const service = new LocalSecretService(vars)
-    const result = (await service.getSecret('CONFIG')).reveal()
-    assert.deepStrictEqual(result, { port: 3000 })
-  })
-
-  test('should throw when JSON secret not found', async () => {
-    const vars = new LocalVariablesService({})
-    const service = new LocalSecretService(vars)
-    await assert.rejects(() => service.getSecret('MISSING'), {
-      message: 'Requested secret not found: MISSING',
-    })
-  })
-
-  test('should prefer local storage over env variables', async () => {
-    const vars = new LocalVariablesService({ KEY: 'env-value' })
-    const service = new LocalSecretService(vars)
-    await service.setSecret('KEY', 'local-value')
-    const result = (await service.getSecret('KEY')).reveal()
-    assert.strictEqual(result, 'local-value')
-  })
-
-  test('should check hasSecret in local storage', async () => {
-    const vars = new LocalVariablesService({})
-    const service = new LocalSecretService(vars)
-    await service.setSecret('EXISTS', 'yes')
-    assert.strictEqual(await service.hasSecret('EXISTS'), true)
-    assert.strictEqual(await service.hasSecret('NOPE'), false)
-  })
-
-  test('should check hasSecret in environment', async () => {
-    const vars = new LocalVariablesService({ ENV_KEY: 'val' })
-    const service = new LocalSecretService(vars)
-    assert.strictEqual(await service.hasSecret('ENV_KEY'), true)
-  })
-
-  test('should delete secret from local storage', async () => {
-    const service = new LocalSecretService()
-    await service.setSecret('DEL_KEY', 'value')
-    assert.strictEqual(await service.hasSecret('DEL_KEY'), true)
-    await service.deleteSecret('DEL_KEY')
-    assert.strictEqual(await service.hasSecret('DEL_KEY'), false)
-  })
-})
-
-describe('LocalSecretService round-trips a wrapped secret', () => {
-  test('setSecret unwraps rather than storing the redaction', async () => {
-    const service = new LocalSecretService()
-    await service.setSecret('SOURCE', 'sk-live-DEADBEEF')
-    const read = await service.getSecret('SOURCE')
-
-    await service.setSecret('COPY', read)
-
-    assert.strictEqual(
-      (await service.getSecret('COPY')).reveal(),
-      'sk-live-DEADBEEF'
-    )
-  })
-})