@pikku/mongodb 0.12.3 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @pikku/mongodb
 
+## 0.12.4
+
+### Patch Changes
+
+- 311c0c4: Unify session persistence through SessionStore, remove session blob from ChannelStore
+
+  - PikkuSessionService now persists sessions via SessionStore on set()/clear() instead of every function call
+  - ChannelStore no longer stores session data — maps channelId to pikkuUserId only
+  - ChannelStore API: setUserSession/getChannelAndSession replaced with setPikkuUserId/getChannel
+  - Serverless channel runner resolves sessions from SessionStore using pikkuUserId from ChannelStore
+
+- Updated dependencies [311c0c4]
+  - @pikku/core@0.12.18
+
 ## 0.12.3
 
 ### Patch Changes

package/dist/src/index.d.ts

@@ -10,3 +10,4 @@ export { MongoDBSecretService } from './mongodb-secret-service.js';
 export type { MongoDBSecretServiceConfig } from './mongodb-secret-service.js';
 export type { WorkflowRunService } from '@pikku/core/workflow';
 export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent';
+export { MongoDBSessionStore } from './mongodb-session-store.js';

package/dist/src/index.js

@@ -7,3 +7,4 @@ export { MongoDBDeploymentService } from './mongodb-deployment-service.js';
 export { MongoDBAIStorageService } from './mongodb-ai-storage-service.js';
 export { MongoDBAgentRunService } from './mongodb-agent-run-service.js';
 export { MongoDBSecretService } from './mongodb-secret-service.js';
+export { MongoDBSessionStore } from './mongodb-session-store.js';

package/dist/src/mongodb-channel-store.d.ts

@@ -1,4 +1,3 @@
-import type { CoreUserSession } from '@pikku/core';
 import type { Channel } from '@pikku/core/channel';
 import { ChannelStore } from '@pikku/core/channel';
 import type { Db } from 'mongodb';
@@ -11,9 +10,9 @@ export declare class MongoDBChannelStore extends ChannelStore {
     init(): Promise<void>;
     addChannel({ channelId, channelName, openingData, }: Channel): Promise<void>;
     removeChannels(channelIds: string[]): Promise<void>;
-    setUserSession(channelId: string, session: CoreUserSession | null): Promise<void>;
-    getChannelAndSession(channelId: string): Promise<Channel & {
-        session: CoreUserSession;
+    setPikkuUserId(channelId: string, pikkuUserId: string | null): Promise<void>;
+    getChannel(channelId: string): Promise<Channel & {
+        pikkuUserId?: string;
     }>;
     close(): Promise<void>;
 }

package/dist/src/mongodb-channel-store.js

@@ -22,7 +22,7 @@ export class MongoDBChannelStore extends ChannelStore {
             _id: channelId,
             channelName,
             openingData: openingData || {},
-            userSession: null,
+            pikkuUserId: null,
             createdAt: new Date(),
             lastWire: new Date(),
         });
@@ -33,10 +33,10 @@ export class MongoDBChannelStore extends ChannelStore {
         await this.channels.deleteMany({ _id: { $in: channelIds } });
         await this.subscriptions.deleteMany({ channelId: { $in: channelIds } });
     }
-    async setUserSession(channelId, session) {
-        await this.channels.updateOne({ _id: channelId }, { $set: { userSession: session } });
+    async setPikkuUserId(channelId, pikkuUserId) {
+        await this.channels.updateOne({ _id: channelId }, { $set: { pikkuUserId } });
     }
-    async getChannelAndSession(channelId) {
+    async getChannel(channelId) {
         const row = await this.channels.findOne({ _id: channelId });
         if (!row) {
             throw new Error(`Channel not found: ${channelId}`);
@@ -45,7 +45,7 @@ export class MongoDBChannelStore extends ChannelStore {
             channelId: row._id,
             channelName: row.channelName,
             openingData: row.openingData ?? {},
-            session: (row.userSession ?? {}),
+            pikkuUserId: row.pikkuUserId ?? undefined,
         };
     }
     async close() { }

package/dist/src/mongodb-deployment-service.d.ts

@@ -1,17 +1,20 @@
-import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig, DeploymentInfo } from '@pikku/core/services';
+import type { DeploymentService, DeploymentServiceConfig, DeploymentConfig } from '@pikku/core/services';
+import type { JWTService, SecretService } from '@pikku/core/services';
 import type { Db } from 'mongodb';
 export declare class MongoDBDeploymentService implements DeploymentService {
     private db;
+    private jwt?;
+    private secrets?;
     private initialized;
     private heartbeatTimer?;
     private deploymentConfig?;
     private heartbeatInterval;
     private heartbeatTtl;
     private deployments;
-    constructor(config: DeploymentServiceConfig, db: Db);
+    constructor(config: DeploymentServiceConfig, db: Db, jwt?: JWTService | undefined, secrets?: SecretService | undefined);
     init(): Promise<void>;
     start(config: DeploymentConfig): Promise<void>;
     stop(): Promise<void>;
-    findFunction(name: string): Promise<DeploymentInfo[]>;
+    invoke(funcName: string, data: unknown, session?: unknown, traceId?: string): Promise<unknown>;
     private sendHeartbeat;
 }

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

@@ -1,14 +1,19 @@
+import { buildRemoteHeaders } from '@pikku/core/remote';
 import { getAllFunctionNames } from '@pikku/core/function';
 export class MongoDBDeploymentService {
     db;
+    jwt;
+    secrets;
     initialized = false;
     heartbeatTimer;
     deploymentConfig;
     heartbeatInterval;
     heartbeatTtl;
     deployments;
-    constructor(config, db) {
+    constructor(config, db, jwt, secrets) {
         this.db = db;
+        this.jwt = jwt;
+        this.secrets = secrets;
         this.heartbeatInterval = config.heartbeatInterval ?? 10000;
         this.heartbeatTtl = config.heartbeatTtl ?? 30000;
     }
@@ -48,19 +53,23 @@ export class MongoDBDeploymentService {
             });
         }
     }
-    async findFunction(name) {
+    async invoke(funcName, data, session, traceId) {
+        const headers = await buildRemoteHeaders(this.jwt, this.secrets, funcName, session, traceId);
         const cutoff = new Date(Date.now() - this.heartbeatTtl);
-        const result = await this.deployments
-            .find({
-            functions: name,
-            lastHeartbeat: { $gt: cutoff },
-        })
-            .sort({ lastHeartbeat: -1 })
-            .toArray();
-        return result.map((row) => ({
-            deploymentId: row._id,
-            endpoint: row.endpoint,
-        }));
+        const result = await this.deployments.findOne({ functions: funcName, lastHeartbeat: { $gt: cutoff } }, { sort: { lastHeartbeat: -1 } });
+        if (!result) {
+            throw new Error(`No deployment found for function '${funcName}'`);
+        }
+        const url = `${result.endpoint}/remote/rpc/${encodeURIComponent(funcName)}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...headers },
+            body: JSON.stringify({ data }),
+        });
+        if (!response.ok) {
+            throw new Error(`Remote RPC call to '${funcName}' failed: ${response.status}`);
+        }
+        return response.json();
     }
     async sendHeartbeat() {
         if (!this.deploymentConfig)

package/dist/src/mongodb-session-store.d.ts

@@ -0,0 +1,14 @@
+import type { CoreUserSession } from '@pikku/core';
+import type { SessionStore } from '@pikku/core/services';
+import type { Db } from 'mongodb';
+export declare class MongoDBSessionStore implements SessionStore {
+    private db;
+    private initialized;
+    private sessions;
+    constructor(db: Db);
+    init(): Promise<void>;
+    get(pikkuUserId: string): Promise<CoreUserSession | undefined>;
+    set(pikkuUserId: string, session: CoreUserSession): Promise<void>;
+    clear(pikkuUserId: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/src/mongodb-session-store.js

@@ -0,0 +1,32 @@
+export class MongoDBSessionStore {
+    db;
+    initialized = false;
+    sessions;
+    constructor(db) {
+        this.db = db;
+    }
+    async init() {
+        if (this.initialized)
+            return;
+        this.sessions = this.db.collection('pikkuUserSessions');
+        this.initialized = true;
+    }
+    async get(pikkuUserId) {
+        const doc = await this.sessions.findOne({ _id: pikkuUserId });
+        if (!doc) {
+            return undefined;
+        }
+        return doc.session;
+    }
+    async set(pikkuUserId, session) {
+        const now = new Date();
+        await this.sessions.updateOne({ _id: pikkuUserId }, {
+            $set: { session, updatedAt: now },
+            $setOnInsert: { createdAt: now },
+        }, { upsert: true });
+    }
+    async clear(pikkuUserId) {
+        await this.sessions.deleteOne({ _id: pikkuUserId });
+    }
+    async close() { }
+}

package/dist/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/index.ts","../src/mongodb-agent-run-service.ts","../src/mongodb-ai-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-workflow-run-service.ts","../src/mongodb-workflow-service.ts","../src/pikku-mongodb.ts"],"version":"5.9.3"}
+{"root":["../src/index.ts","../src/mongodb-agent-run-service.ts","../src/mongodb-ai-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":"5.9.3"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/mongodb",
-  "version": "0.12.3",
+  "version": "0.12.4",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/src/index.js",
@@ -17,7 +17,7 @@
     "prepublishOnly": "yarn build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.9"
+    "@pikku/core": "^0.12.18"
   },
   "dependencies": {
     "mongodb": "^6.12.0"

package/src/index.ts

@@ -12,3 +12,4 @@ export type { MongoDBSecretServiceConfig } from './mongodb-secret-service.js'
 
 export type { WorkflowRunService } from '@pikku/core/workflow'
 export type { AgentRunService, AgentRunRow } from '@pikku/core/ai-agent'
+export { MongoDBSessionStore } from './mongodb-session-store.js'

package/src/mongodb-channel-store.ts

@@ -1,4 +1,3 @@
-import type { CoreUserSession } from '@pikku/core'
 import type { Channel } from '@pikku/core/channel'
 import { ChannelStore } from '@pikku/core/channel'
 import type { Db, Collection } from 'mongodb'
@@ -8,7 +7,7 @@ interface ChannelDoc {
   channelName: string
   createdAt: Date
   openingData: any
-  userSession: any | null
+  pikkuUserId: string | null
   lastWire: Date
 }
 
@@ -52,7 +51,7 @@ export class MongoDBChannelStore extends ChannelStore {
       _id: channelId,
       channelName,
       openingData: openingData || {},
-      userSession: null,
+      pikkuUserId: null,
       createdAt: new Date(),
       lastWire: new Date(),
     })
@@ -65,19 +64,16 @@ export class MongoDBChannelStore extends ChannelStore {
     await this.subscriptions.deleteMany({ channelId: { $in: channelIds } })
   }
 
-  public async setUserSession(
+  public async setPikkuUserId(
     channelId: string,
-    session: CoreUserSession | null
+    pikkuUserId: string | null
   ): Promise<void> {
-    await this.channels.updateOne(
-      { _id: channelId },
-      { $set: { userSession: session } }
-    )
+    await this.channels.updateOne({ _id: channelId }, { $set: { pikkuUserId } })
   }
 
-  public async getChannelAndSession(
+  public async getChannel(
     channelId: string
-  ): Promise<Channel & { session: CoreUserSession }> {
+  ): Promise<Channel & { pikkuUserId?: string }> {
     const row = await this.channels.findOne({ _id: channelId })
 
     if (!row) {
@@ -88,7 +84,7 @@ export class MongoDBChannelStore extends ChannelStore {
       channelId: row._id,
       channelName: row.channelName,
       openingData: row.openingData ?? {},
-      session: (row.userSession ?? {}) as CoreUserSession,
+      pikkuUserId: row.pikkuUserId ?? undefined,
     }
   }
 

package/src/mongodb-deployment-service.ts

@@ -1,9 +1,10 @@
+import { buildRemoteHeaders } from '@pikku/core/remote'
 import type {
   DeploymentService,
   DeploymentServiceConfig,
   DeploymentConfig,
-  DeploymentInfo,
 } from '@pikku/core/services'
+import type { JWTService, SecretService } from '@pikku/core/services'
 import { getAllFunctionNames } from '@pikku/core/function'
 import type { Db, Collection } from 'mongodb'
 
@@ -25,7 +26,9 @@ export class MongoDBDeploymentService implements DeploymentService {
 
   constructor(
     config: DeploymentServiceConfig,
-    private db: Db
+    private db: Db,
+    private jwt?: JWTService,
+    private secrets?: SecretService
   ) {
     this.heartbeatInterval = config.heartbeatInterval ?? 10000
     this.heartbeatTtl = config.heartbeatTtl ?? 30000
@@ -82,21 +85,39 @@ export class MongoDBDeploymentService implements DeploymentService {
     }
   }
 
-  async findFunction(name: string): Promise<DeploymentInfo[]> {
+  async invoke(
+    funcName: string,
+    data: unknown,
+    session?: unknown,
+    traceId?: string
+  ): Promise<unknown> {
+    const headers = await buildRemoteHeaders(
+      this.jwt,
+      this.secrets,
+      funcName,
+      session,
+      traceId
+    )
     const cutoff = new Date(Date.now() - this.heartbeatTtl)
-
-    const result = await this.deployments
-      .find({
-        functions: name,
-        lastHeartbeat: { $gt: cutoff },
-      })
-      .sort({ lastHeartbeat: -1 })
-      .toArray()
-
-    return result.map((row) => ({
-      deploymentId: row._id,
-      endpoint: row.endpoint,
-    }))
+    const result = await this.deployments.findOne(
+      { functions: funcName, lastHeartbeat: { $gt: cutoff } },
+      { sort: { lastHeartbeat: -1 } }
+    )
+    if (!result) {
+      throw new Error(`No deployment found for function '${funcName}'`)
+    }
+    const url = `${result.endpoint}/remote/rpc/${encodeURIComponent(funcName)}`
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', ...headers },
+      body: JSON.stringify({ data }),
+    })
+    if (!response.ok) {
+      throw new Error(
+        `Remote RPC call to '${funcName}' failed: ${response.status}`
+      )
+    }
+    return response.json()
   }
 
   private async sendHeartbeat(): Promise<void> {

package/src/mongodb-services.test.ts

@@ -12,6 +12,7 @@ import { MongoDBDeploymentService } from './mongodb-deployment-service.js'
 import { MongoDBAIStorageService } from './mongodb-ai-storage-service.js'
 import { MongoDBAgentRunService } from './mongodb-agent-run-service.js'
 import { MongoDBSecretService } from './mongodb-secret-service.js'
+import { MongoDBSessionStore } from './mongodb-session-store.js'
 
 function registerTests(name: string, getDb: () => Db) {
   defineServiceTests({
@@ -52,6 +53,11 @@ function registerTests(name: string, getDb: () => Db) {
         await s.init()
         return s
       },
+      sessionStore: async () => {
+        const s = new MongoDBSessionStore(getDb())
+        await s.init()
+        return s
+      },
     },
   })
 

package/src/mongodb-session-store.ts

@@ -0,0 +1,50 @@
+import type { CoreUserSession } from '@pikku/core'
+import type { SessionStore } from '@pikku/core/services'
+import type { Db, Collection } from 'mongodb'
+
+interface SessionDoc {
+  _id: string
+  session: any
+  createdAt: Date
+  updatedAt: Date
+}
+
+export class MongoDBSessionStore implements SessionStore {
+  private initialized = false
+  private sessions!: Collection<SessionDoc>
+
+  constructor(private db: Db) {}
+
+  public async init(): Promise<void> {
+    if (this.initialized) return
+
+    this.sessions = this.db.collection<SessionDoc>('pikkuUserSessions')
+    this.initialized = true
+  }
+
+  async get(pikkuUserId: string): Promise<CoreUserSession | undefined> {
+    const doc = await this.sessions.findOne({ _id: pikkuUserId })
+    if (!doc) {
+      return undefined
+    }
+    return doc.session as CoreUserSession
+  }
+
+  async set(pikkuUserId: string, session: CoreUserSession): Promise<void> {
+    const now = new Date()
+    await this.sessions.updateOne(
+      { _id: pikkuUserId },
+      {
+        $set: { session, updatedAt: now },
+        $setOnInsert: { createdAt: now },
+      },
+      { upsert: true }
+    )
+  }
+
+  async clear(pikkuUserId: string): Promise<void> {
+    await this.sessions.deleteOne({ _id: pikkuUserId })
+  }
+
+  public async close(): Promise<void> {}
+}