@pikku/core 0.12.31 → 0.12.33

package/src/services/scoped-secret-service.test.ts

@@ -7,6 +7,8 @@ const createMockSecrets = () => ({
   hasSecret: async () => true,
   setSecret: async () => {},
   deleteSecret: async () => {},
+  getSecrets: async <T>(keys: string[]) =>
+    Object.fromEntries(keys.map((key) => [key, { key }])) as T,
 })
 
 describe('ScopedSecretService', () => {
@@ -55,6 +57,24 @@ describe('ScopedSecretService', () => {
     })
   })
 
+  test('should return batch secrets for allowed keys', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1', 'KEY2']))
+    const result = await scoped.getSecrets(['KEY1', 'KEY2'])
+    assert.deepStrictEqual(result, {
+      KEY1: { key: 'KEY1' },
+      KEY2: { key: 'KEY2' },
+    })
+  })
+
+  test('should reject batch getSecrets when any key is not allowed', async () => {
+    const mock = createMockSecrets()
+    const scoped = new ScopedSecretService(mock, new Set(['KEY1']))
+    await assert.rejects(() => scoped.getSecrets(['KEY1', 'KEY2']), {
+      message: 'Access denied to secret key: KEY2',
+    })
+  })
+
   test('should always throw on setSecret', async () => {
     const mock = createMockSecrets()
     const scoped = new ScopedSecretService(mock, new Set(['KEY1']))

package/src/services/scoped-secret-service.ts

@@ -34,8 +34,10 @@ export class ScopedSecretService implements SecretService {
     throw new Error('deleteSecret is not allowed in scoped secret service')
   }
 
-  async getSecrets(keys: string[]): Promise<Record<string, unknown>> {
-    const allowed = keys.filter((k) => this.allowedKeys.has(k))
-    return this.secrets.getSecrets(allowed)
+  async getSecrets<T extends Record<string, unknown> = Record<string, unknown>>(
+    keys: (keyof T & string)[]
+  ): Promise<Partial<T>> {
+    keys.forEach((k) => this.assertAllowed(k))
+    return this.secrets.getSecrets<T>(keys)
   }
 }

package/src/services/secret-service.ts

@@ -31,8 +31,14 @@ export interface SecretService {
   /**
    * Retrieves multiple secrets in a single batch operation.
    * Returns a map of key → value for successfully fetched secrets; missing
-   * keys are omitted rather than throwing.
+   * keys are omitted rather than throwing, so the result is typed as
+   * `Partial<T>` and callers must handle keys that may be absent at runtime.
+   *
+   * Pass a shape as `T` to get a typed result without casting, e.g.
+   * `await secrets.getSecrets<{ FOO: string; BAR: { id: string } }>(['FOO', 'BAR'])`.
    * @param keys - The keys of the secrets to retrieve.
    */
-  getSecrets(keys: string[]): Promise<Record<string, unknown>>
+  getSecrets<T extends Record<string, unknown> = Record<string, unknown>>(
+    keys: (keyof T & string)[]
+  ): Promise<Partial<T>>
 }

package/src/services/temporary-file-service.ts

@@ -0,0 +1,76 @@
+import { createReadStream, createWriteStream } from 'fs'
+import { mkdir, rm, stat } from 'fs/promises'
+import { resolve } from 'path'
+import { pipeline } from 'stream/promises'
+import type { Readable } from 'stream'
+import type { Logger } from './logger.js'
+
+export class TemporaryFileInstance {
+  private files: string[] = []
+
+  constructor(
+    private logger: Logger,
+    private tempDir: string
+  ) {
+    this.tempDir = resolve(tempDir)
+    logger.debug(`Using temp dir ${this.tempDir}`)
+  }
+
+  public getFile(key: string): ReadableStream | NodeJS.ReadableStream {
+    return createReadStream(`${this.tempDir}/${key}`)
+  }
+
+  public async writeFile(
+    key: string,
+    stream: ReadableStream | NodeJS.ReadableStream
+  ): Promise<void> {
+    await this.createDir(key)
+    const filePath = `${this.tempDir}/${key}`
+    const fileStream = createWriteStream(filePath)
+    await pipeline(stream as Readable, fileStream)
+    this.files.push(filePath)
+    this.logger.debug(`Wrote file: ${filePath}`)
+  }
+
+  public async deleteFile(key: string): Promise<void> {
+    await rm(`${this.tempDir}/${key}`)
+    this.logger.debug(`Deleted file ${this.tempDir}/${key}`)
+  }
+
+  public async hasFile(key: string): Promise<boolean> {
+    try {
+      return !!(await stat(`${this.tempDir}/${key}`))
+    } catch {
+      return false
+    }
+  }
+
+  public async getTempFileAbsolutePath(key: string): Promise<string> {
+    await this.createDir(key)
+    return `${this.tempDir}/${key}`
+  }
+
+  private async createDir(key: string) {
+    const dir = `${this.tempDir}/${key}`.split('/').slice(0, -1).join('/')
+    if (!(await this.hasFile(dir))) {
+      await mkdir(dir, { recursive: true })
+    }
+  }
+
+  public async cleanup() {
+    await Promise.all(this.files.map((file) => rm(file)))
+  }
+}
+
+export class TemporaryFileService {
+  constructor(
+    private logger: Logger,
+    private tempDir: string
+  ) {
+    this.tempDir = resolve(tempDir)
+  }
+
+  public createInstance() {
+    return new TemporaryFileInstance(this.logger, this.tempDir)
+  }
+}

package/src/services/typed-secret-service.ts

@@ -43,8 +43,10 @@ export class TypedSecretService<
     return this.secrets.deleteSecret(key)
   }
 
-  async getSecrets(keys: string[]): Promise<Record<string, unknown>> {
-    return this.secrets.getSecrets(keys)
+  async getSecrets<T extends Record<string, unknown> = Record<string, unknown>>(
+    keys: (keyof T & string)[]
+  ): Promise<Partial<T>> {
+    return this.secrets.getSecrets<T>(keys)
   }
 
   async getAllStatus(): Promise<CredentialStatus[]> {

package/src/services/typed-variables-service.ts

@@ -28,6 +28,12 @@ export class TypedVariablesService<
     return this.variables.get(name)
   }
 
+  getVariables<T extends Record<string, unknown> = Record<string, unknown>>(
+    names: (keyof T & string)[]
+  ): Promise<Partial<T>> | Partial<T> {
+    return this.variables.getVariables<T>(names)
+  }
+
   getAll():
     | Promise<Record<string, string | undefined>>
     | Record<string, string | undefined> {

package/src/services/variables-service.ts

@@ -1,5 +1,16 @@
 export interface VariablesService {
   get<T = string>(name: string): Promise<T | undefined> | T | undefined
+  /**
+   * Retrieves multiple variables in a single batch operation, mirroring
+   * `SecretService.getSecrets`. Missing variables are omitted rather than
+   * throwing, so the result is typed as `Partial<T>` and callers must handle
+   * keys that may be absent at runtime. Pass a shape as `T` to get a typed
+   * result without casting, e.g.
+   * `await variables.getVariables<{ FOO: string; BAR: string }>(['FOO', 'BAR'])`.
+   */
+  getVariables<T extends Record<string, unknown> = Record<string, unknown>>(
+    names: (keyof T & string)[]
+  ): Promise<Partial<T>> | Partial<T>
   getAll: () =>
     | Promise<Record<string, string | undefined>>
     | Record<string, string | undefined>

package/src/types/state.types.ts

@@ -171,6 +171,11 @@ export interface PikkuPackageState {
     } | null
     /** Cached singleton services for this package */
     singletonServices: CoreSingletonServices | null
+    /** The pikkuBetterAuth factory, self-registered when auth.ts is evaluated.
+     *  pikkuServices reads it to build and inject the `auth` singleton. */
+    authFactory:
+      | ((services: CoreSingletonServices) => unknown | Promise<unknown>)
+      | null
     /** Credential metadata for this addon package */
     credentialsMeta: Record<
       string,

package/src/wirings/http/http-runner.test.ts

@@ -272,6 +272,19 @@ describe('http-runner helpers', () => {
     )
   })
 
+  test('addHTTPMiddleware composes repeated registrations for the same pattern', () => {
+    const first: CorePikkuMiddleware = async (_s, _w, next) => next()
+    const second: CorePikkuMiddleware = async (_s, _w, next) => next()
+
+    addHTTPMiddleware('*', [first])
+    addHTTPMiddleware('*', [second])
+
+    assert.deepEqual(pikkuState(null, 'middleware', 'httpGroup')['*'], [
+      first,
+      second,
+    ])
+  })
+
   test('createHTTPWire combines request and response when present', () => {
     const req = new TestRequest('/x', 'get')
     const res = new TestResponse()

package/src/wirings/http/http-runner.ts

@@ -96,7 +96,10 @@ export const addHTTPMiddleware = <PikkuMiddleware extends CorePikkuMiddleware>(
   packageName: string | null = null
 ): CorePikkuMiddlewareGroup => {
   const httpGroups = pikkuState(packageName, 'middleware', 'httpGroup')
-  httpGroups[pattern] = middleware
+  const existing = httpGroups[pattern] as CorePikkuMiddleware[] | undefined
+  httpGroups[pattern] = existing
+    ? [...existing, ...(middleware as CorePikkuMiddleware[])]
+    : middleware
   return middleware
 }
 

package/src/wirings/http/pikku-fetch-http-request.ts

@@ -16,7 +16,7 @@ export class PikkuFetchHTTPRequest<
   #url: URL
   #rawBodyText: string | undefined
   #rawBodyBuffer: ArrayBuffer | undefined
-  #bodyRead = false
+  #rawBufferPromise: Promise<ArrayBuffer> | undefined
 
   constructor(private request: Request) {
     this.#url = new URL(request.url)
@@ -44,36 +44,53 @@ export class PikkuFetchHTTPRequest<
    * @returns A promise that resolves to the raw request body.
    */
   public async arrayBuffer(): Promise<ArrayBuffer> {
+    return this.#readRawBuffer()
+  }
+
+  /**
+   * Reads the underlying single-use request body exactly once and memoises both
+   * the in-flight promise and the result. `json()`, `arrayBuffer()`, `body()`
+   * and `toWebRequest()` all funnel through here, so a request whose body is
+   * consumed in more than one place can no longer race on the underlying stream
+   * and fail with "Body has already been used".
+   *
+   * If a second consumer asks for the body while the first read is still in
+   * flight, that is the concurrent double-read that used to crash — now safe,
+   * but warned about so the redundant consumer is found and removed at the
+   * source rather than silently leaning on this cache.
+   */
+  async #readRawBuffer(): Promise<ArrayBuffer> {
     if (this.#rawBodyBuffer !== undefined) {
       return this.#rawBodyBuffer
     }
-    if (this.#bodyRead) {
-      if (this.#rawBodyText !== undefined) {
-        const buf = new TextEncoder().encode(this.#rawBodyText)
-          .buffer as ArrayBuffer
-        this.#rawBodyBuffer = buf
-        return buf
-      }
-      return new ArrayBuffer(0)
+    if (this.#rawBodyText !== undefined) {
+      const buf = new TextEncoder().encode(this.#rawBodyText)
+        .buffer as ArrayBuffer
+      this.#rawBodyBuffer = buf
+      return buf
+    }
+    if (this.#rawBufferPromise !== undefined) {
+      console.warn(
+        `[pikku] request body for ${this.method().toUpperCase()} ${this.path()} ` +
+          `was requested again before the first read resolved — the read is now ` +
+          `shared, but a duplicate body consumer (e.g. middleware calling ` +
+          `toWebRequest just for headers) should be removed.`
+      )
+      return this.#rawBufferPromise
     }
-    const buf = await this.request.arrayBuffer()
-    this.#rawBodyBuffer = buf
-    this.#bodyRead = true
-    return buf
+    this.#rawBufferPromise = this.request.arrayBuffer().then((buf) => {
+      this.#rawBodyBuffer = buf
+      return buf
+    })
+    return this.#rawBufferPromise
   }
 
   async #readRawText(): Promise<string> {
     if (this.#rawBodyText !== undefined) {
       return this.#rawBodyText
     }
-    if (this.#rawBodyBuffer !== undefined) {
-      const text = new TextDecoder().decode(this.#rawBodyBuffer)
-      this.#rawBodyText = text
-      return text
-    }
-    const text = await this.request.text()
+    const text = new TextDecoder().decode(await this.#readRawBuffer())
     this.#rawBodyText = text
-    this.#bodyRead = true
     return text
   }
 

package/src/wirings/http/web-request.test.ts

@@ -274,8 +274,8 @@ describe('applyWebResponse', () => {
     const { res, state } = createMockResponse()
     const webRes = new Response('{"csrfToken":"abc"}', { status: 200 })
     const cookies = [
-      'authjs.csrf-token=abc; Path=/; HttpOnly',
-      'authjs.callback-url=http%3A%2F%2Flocalhost; Path=/; HttpOnly',
+      'better-auth.session_token=abc; Path=/; HttpOnly',
+      'better-auth.callback-url=http%3A%2F%2Flocalhost; Path=/; HttpOnly',
     ]
     ;(webRes.headers as any).getSetCookie = () => cookies
 

package/src/wirings/http/web-request.ts

@@ -30,8 +30,13 @@ export function toWebRequest(req: PikkuHTTPRequest, baseUrl?: string): Request {
   return new Request(url, {
     method,
     headers,
+    // `pull` (lazy) rather than `start` (eager): the body is only read from the
+    // underlying request when this stream is actually consumed. A consumer that
+    // builds a web Request just to read its headers (e.g. a session middleware
+    // calling getSession({ headers })) never touches the body, so it does zero
+    // body I/O and cannot race the route handler's read of the same request.
     body: new ReadableStream({
-      async start(controller) {
+      async pull(controller) {
         try {
           const buffer = await req.arrayBuffer()
           if (buffer.byteLength > 0) {

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -1174,6 +1174,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       const wire: PikkuWire = {
         workflow: workflowWire,
         pikkuUserId: run.wire?.pikkuUserId,
+        session: rpcService.wire?.session,
         rpc: rpcService.wire?.rpc,
       }
       try {
@@ -1358,6 +1359,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
               id: rpcName,
               parentRunId: runId,
               parentStepId: stepState.stepId,
+              pikkuUserId: rpcService.wire?.pikkuUserId,
             }
             const shouldInline = !getSingletonServices()?.queueService
             const { runId: childRunId } = await this.startWorkflow(
@@ -1555,6 +1557,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
               type: 'workflow',
               id: rpcName,
               parentRunId: runId,
+              pikkuUserId: rpcService.wire?.pikkuUserId,
             }
             const { runId: childRunId } = await this.startWorkflow(
               rpcName,