@pikku/mongodb 0.12.20 → 0.12.22

package/CHANGELOG.md

@@ -1,5 +1,57 @@
 # @pikku/mongodb
 
+## 0.12.22
+
+### Patch Changes
+
+- 4c7a1b5: Run the monorepo's own scripts through bun instead of yarn. What moves is the
+  package manager each package's `prepublishOnly` and build scripts invoke, plus
+  the two manifest fixes bun needs to resolve the tree: `uWebSockets.js` is
+  declared with an explicit `github:` specifier, and `@pikku/uws-handler` marks
+  its `uWebSockets.js` peer optional so a bun install of a consumer that brings
+  its own uWS app does not try to fetch it from the registry.
+
+  Three published behaviours change, all of them cases where an isolated
+  `node_modules` or bun as the runtime had been papered over by yarn's hoisting:
+
+  - `@pikku/migrator-sql` turns foreign keys on when it opens a sqlite database
+    through bun. `node:sqlite` enforces them by default and `bun:sqlite` does not,
+    which silently turned every `ON DELETE CASCADE` into a no-op under
+    `bunx --bun pikku`.
+  - `@pikku/cli` resolves a deploy provider against the project being deployed
+    rather than against wherever the CLI itself is installed, which is what its
+    own "is not installed" error asks the user to arrange.
+  - `@pikku/cli` treats a specifier a runtime hands straight back — bun does this
+    for the modules it implements itself — as not resolved from the project, so
+    it falls back rather than loading the runtime's own copy.
+
+- Updated dependencies [4c7a1b5]
+  - @pikku/core@0.12.108
+
+## 0.12.21
+
+### Patch Changes
+
+- 4450b2a: Name the missing key when a secret is not found.
+
+  Every `SecretService` threw a bare `Requested secret not found`. In a deployed
+  runtime the stack is minified, so the message was the only evidence there was —
+  and it identified neither the key nor the service. Each implementation now names
+  the key it looked for; the better-auth middlewares that skip on an absent secret
+  match the prefix through one shared predicate instead of the whole string.
+
+- Updated dependencies [4058c3a]
+- Updated dependencies [4058c3a]
+- Updated dependencies [4058c3a]
+- Updated dependencies [4058c3a]
+- Updated dependencies [4058c3a]
+- Updated dependencies [4058c3a]
+- Updated dependencies [114c079]
+- Updated dependencies [4450b2a]
+- Updated dependencies [4058c3a]
+- Updated dependencies [4058c3a]
+  - @pikku/core@0.12.93
+
 ## 0.12.20
 
 ### Patch Changes

package/dist/src/mongodb-secret-service.js

@@ -71,7 +71,7 @@ export class MongoDBSecretService {
     async getSecret(key) {
         const row = await this.secrets.findOne({ _id: key });
         if (!row)
-            throw new Error('Requested secret not found');
+            throw new Error(`Requested secret not found: ${key}`);
         const kek = await this.getKEK(row.keyVersion);
         const result = await envelopeDecrypt(kek, row.ciphertext, row.wrappedDek);
         await this.logAudit(key, 'read');

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@pikku/mongodb",
-  "version": "0.12.20",
+  "version": "0.12.22",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/services/mongodb"
+  },
   "description": "MongoDB services for Pikku — workflow state, agent runs, secrets and channel stores",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -15,20 +20,19 @@
     "test:watch": "bash run-tests.sh --watch",
     "test:coverage": "bash run-tests.sh --coverage",
     "release": "npm run build && npm test",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.90"
+    "@pikku/core": "^0.12.108"
   },
   "dependencies": {
     "mongodb": "^7.5.0"
   },
   "devDependencies": {
     "mongodb": "^7.5.0",
-    "mongodb-memory-server": "^11.2.0",
-    "typescript": "^6.0.3"
+    "mongodb-memory-server": "^11.2.0"
   },
   "exports": {
     ".": "./dist/src/index.js"
   }
-}
+}

package/run-tests.sh

@@ -34,20 +34,35 @@ files=($(find src -type f -name "*.test.ts"))
 # Check if any files matched the pattern
 if [ ${#files[@]} -eq 0 ]; then
   echo "No test files found matching pattern: $pattern"
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ]; then
+    exit 1
+  fi
   exit 0
 fi
 
-# Construct the node command
-node_cmd=(node --import tsx --test)
+# Construct the bun command
+#
+# --parallel gives every test file its own worker process, which is what node's
+# `--test` did. Several suites keep module-level caches (a TypeScript program, a
+# temp fixture directory) that a shared process would leak between files.
+#
+# --timeout because bun caps a test at 5s by default where node had no cap, and
+# the suites that build real TypeScript programs run well past that.
+bun_cmd=(bun test --parallel --timeout 120000)
 
 # Append options based on flags
 if [ "$watch_mode" = true ]; then
-  node_cmd+=(--watch)
+  # --watch reruns in one process; parallel workers have nothing to watch.
+  bun_cmd=(bun test --watch --timeout 120000)
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
+  # --coverage-dir=. keeps lcov.info at the package root: CI merges every
+  # package's report by prefixing its SF paths with the file's own directory,
+  # so a nested coverage/ directory would re-root them one level too deep.
+  bun_cmd+=(--coverage --coverage-reporter=lcov --coverage-reporter=text --coverage-dir=.)
+  export PIKKU_TEST_COVERAGE=1
 fi
 
-# Execute the node command with the expanded list of files
-"${node_cmd[@]}" "${files[@]}"
+# Execute the bun command with the expanded list of files
+"${bun_cmd[@]}" "${files[@]}"

package/dist/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["../src/index.ts","../src/mongodb-agent-run-service.ts","../src/mongodb-agent-storage-service.ts","../src/mongodb-channel-store.ts","../src/mongodb-deployment-service.ts","../src/mongodb-eventhub-store.ts","../src/mongodb-secret-service.ts","../src/mongodb-session-store.ts","../src/mongodb-workflow-run-service.ts","../src/mongodb-workflow-service.ts","../src/pikku-mongodb.ts"],"version":"6.0.3"}

package/src/index.ts

@@ -1,14 +0,0 @@
-export { PikkuMongoDB } from './pikku-mongodb.js'
-
-export { MongoDBChannelStore } from './mongodb-channel-store.js'
-export { MongoDBEventHubStore } from './mongodb-eventhub-store.js'
-export { MongoDBWorkflowService } from './mongodb-workflow-service.js'
-export { MongoDBWorkflowRunService } from './mongodb-workflow-run-service.js'
-export { MongoDBDeploymentService } from './mongodb-deployment-service.js'
-export { MongoDBAgentStorageService } from './mongodb-agent-storage-service.js'
-export { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
-export { MongoDBSecretService } from './mongodb-secret-service.js'
-
-export type { WorkflowRunService } from '@pikku/core/workflow'
-export type { AgentRunService, AgentRunRow } from '@pikku/core/agent'
-export { MongoDBSessionStore } from './mongodb-session-store.js'

package/src/mongodb-agent-run-service.ts

@@ -1,234 +0,0 @@
-import type {
-  AgentThread,
-  AgentMessage,
-  AgentRunRow,
-  AgentRunService,
-} from '@pikku/core/agent'
-import type { Db, Collection } from 'mongodb'
-
-// Owner ids are untrusted input to the regex, so metacharacters must not be
-// able to widen the prefix match.
-const escapeRegExp = (value: string) =>
-  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-interface AgentThreadDoc {
-  _id: string
-  resourceId: string
-  title: string | null
-  metadata: any | null
-  createdAt: Date
-  updatedAt: Date
-}
-
-interface AgentMessageDoc {
-  _id: string
-  threadId: string
-  role: string
-  content: string | null
-  createdAt: Date
-}
-
-interface AgentToolCallDoc {
-  _id: string
-  threadId: string
-  messageId: string
-  runId: string | null
-  toolName: string
-  args: any
-  result: string | null
-  approvalStatus: string | null
-  approvalType: string | null
-  agentRunId: string | null
-  displayToolName: string | null
-  displayArgs: any | null
-  createdAt: Date
-}
-
-interface AgentRunDoc {
-  _id: string
-  agentName: string
-  threadId: string
-  resourceId: string
-  status: string
-  errorMessage: string | null
-  suspendReason: string | null
-  missingRpcs: any | null
-  usageInputTokens: number
-  usageOutputTokens: number
-  usageModel: string
-  createdAt: Date
-  updatedAt: Date
-}
-
-export class MongoDBAgentRunService implements AgentRunService {
-  private threads: Collection<AgentThreadDoc>
-  private messages: Collection<AgentMessageDoc>
-  private toolCalls: Collection<AgentToolCallDoc>
-  private runs: Collection<AgentRunDoc>
-
-  constructor(db: Db) {
-    this.threads = db.collection<AgentThreadDoc>('agent_threads')
-    this.messages = db.collection<AgentMessageDoc>('agent_message')
-    this.toolCalls = db.collection<AgentToolCallDoc>('agent_tool_call')
-    this.runs = db.collection<AgentRunDoc>('agent_run')
-  }
-
-  async listThreads(options?: {
-    agentName?: string
-    resourceId?: string
-    owners?: string[]
-    limit?: number
-    offset?: number
-  }): Promise<AgentThread[]> {
-    const {
-      agentName,
-      resourceId,
-      owners,
-      limit = 50,
-      offset = 0,
-    } = options ?? {}
-
-    // An owners constraint is an authorization boundary, so an empty list must
-    // match nothing rather than degrade to "no filter".
-    if (owners && owners.length === 0) return []
-
-    let filter: Record<string, any> = {}
-
-    if (resourceId) {
-      filter.resourceId = resourceId
-    }
-
-    if (owners) {
-      filter.$or = owners.flatMap((owner) => [
-        { resourceId: owner },
-        { resourceId: { $regex: `^${escapeRegExp(owner)}:` } },
-      ])
-    }
-
-    if (agentName) {
-      const threadIds = await this.runs.distinct('threadId', {
-        agentName,
-      })
-      filter._id = { $in: threadIds }
-    }
-
-    const result = await this.threads
-      .find(filter)
-      .sort({ updatedAt: -1 })
-      .skip(offset)
-      .limit(limit)
-      .toArray()
-
-    return result.map((row) => this.mapThreadRow(row))
-  }
-
-  async getThread(threadId: string): Promise<AgentThread | null> {
-    const row = await this.threads.findOne({ _id: threadId })
-    if (!row) return null
-    return this.mapThreadRow(row)
-  }
-
-  async getThreadMessages(threadId: string): Promise<AgentMessage[]> {
-    const [msgResult, tcResult] = await Promise.all([
-      this.messages.find({ threadId }).sort({ createdAt: 1 }).toArray(),
-      this.toolCalls.find({ threadId }).sort({ createdAt: 1 }).toArray(),
-    ])
-
-    const tcByMessage = new Map<string, (typeof tcResult)[number][]>()
-    for (const tc of tcResult) {
-      const msgId = tc.messageId
-      if (!tcByMessage.has(msgId)) tcByMessage.set(msgId, [])
-      tcByMessage.get(msgId)!.push(tc)
-    }
-
-    const messages: AgentMessage[] = []
-    for (const row of msgResult) {
-      const msg: AgentMessage = {
-        id: row._id,
-        role: row.role as AgentMessage['role'],
-        content: row.content ?? undefined,
-        createdAt: new Date(row.createdAt),
-      }
-
-      const tcs = tcByMessage.get(msg.id)
-      if (tcs?.length) {
-        msg.toolCalls = tcs.map((tc) => ({
-          id: tc._id,
-          name: tc.toolName,
-          args: tc.args as Record<string, unknown>,
-        }))
-
-        const completed = tcs.filter((tc) => tc.result != null)
-        if (completed.length) {
-          messages.push(msg)
-          messages.push({
-            id: `tool-results-${msg.id}`,
-            role: 'tool',
-            toolResults: completed.map((tc) => ({
-              id: tc._id,
-              name: tc.toolName,
-              result: tc.result!,
-            })),
-            createdAt: msg.createdAt,
-          })
-          continue
-        }
-      }
-
-      messages.push(msg)
-    }
-
-    return messages
-  }
-
-  async getThreadRuns(threadId: string): Promise<AgentRunRow[]> {
-    const result = await this.runs
-      .find({ threadId })
-      .sort({ createdAt: -1 })
-      .toArray()
-
-    return result.map((row) => this.mapRunRow(row))
-  }
-
-  async deleteThread(threadId: string): Promise<boolean> {
-    await this.toolCalls.deleteMany({ threadId })
-    await this.messages.deleteMany({ threadId })
-    await this.runs.deleteMany({ threadId })
-    const result = await this.threads.deleteOne({ _id: threadId })
-    return result.deletedCount > 0
-  }
-
-  async getDistinctAgentNames(): Promise<string[]> {
-    const result = await this.runs.distinct('agentName')
-    return result.sort()
-  }
-
-  private mapThreadRow(row: AgentThreadDoc): AgentThread {
-    return {
-      id: row._id,
-      resourceId: row.resourceId,
-      title: row.title ?? undefined,
-      metadata: row.metadata ?? undefined,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-    }
-  }
-
-  private mapRunRow(row: AgentRunDoc): AgentRunRow {
-    return {
-      runId: row._id,
-      agentName: row.agentName,
-      threadId: row.threadId,
-      resourceId: row.resourceId,
-      status: row.status,
-      errorMessage: row.errorMessage ?? undefined,
-      suspendReason: row.suspendReason ?? undefined,
-      missingRpcs: row.missingRpcs ?? undefined,
-      usageInputTokens: Number(row.usageInputTokens),
-      usageOutputTokens: Number(row.usageOutputTokens),
-      usageModel: row.usageModel,
-      createdAt: new Date(row.createdAt),
-      updatedAt: new Date(row.updatedAt),
-    }
-  }
-}