@ossy/platform 3.24.1 → 3.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/platform",
-  "version": "3.24.1",
+  "version": "3.26.0",
   "description": "Ossy application server runtime",
   "repository": {
     "type": "git",
@@ -49,18 +49,18 @@
     "@aws-sdk/util-format-url": "^3.972.17",
     "@modelcontextprotocol/sdk": "^1.12.1",
     "@ossy/config": "^3.0.9",
-    "@ossy/email": "^3.24.1",
-    "@ossy/event-store": "^3.24.1",
+    "@ossy/email": "^3.26.0",
+    "@ossy/event-store": "^3.26.0",
     "@ossy/locale": "^3.4.0",
     "@ossy/manifest": "^3.24.0",
     "@ossy/observability": "^3.24.1",
     "@ossy/policies": "^3.24.1",
-    "@ossy/router": "^3.0.9",
+    "@ossy/router": "^3.25.0",
     "@ossy/schema": "^3.24.0",
-    "@ossy/sdk": "^3.24.0",
+    "@ossy/sdk": "^3.26.0",
     "@ossy/tokens": "^3.24.1",
     "@ossy/users": "^3.24.1",
-    "@ossy/workspaces": "^3.24.1",
+    "@ossy/workspaces": "^3.26.0",
     "cookie-parser": "^1.4.7",
     "dotenv": ">=16.0.0 <18.0.0",
     "express": ">=5.0.0 <6.0.0",
@@ -81,5 +81,5 @@
     "Dockerfile",
     "docker-healthcheck.js"
   ],
-  "gitHead": "d0e7eda0397239d5e8a8cd5115d9c91959b4103f"
+  "gitHead": "0df308a330150a890b9dd4d6ffc2e9f28bd31966"
 }

package/src/runtime.js

@@ -187,7 +187,8 @@ export async function startRuntime ({ port } = {}) {
       const { language, messages, fallbackMessages } = resolveRequestLocale(pageRouter, requestUrl, buildDir, config)
       if (typeof pageEntry.redirect === 'string' && pageEntry.redirect.trim()) {
         const targetId = pageEntry.redirect.trim().replace(/^@/, '')
-        const targetPath = pageRouter.getPathname({ id: targetId, language })
+        const params = pageRouter.getParamsFromUrl(requestUrl)
+        const targetPath = pageRouter.getPathname({ id: targetId, language, params })
         if (targetPath) {
           const search = new URL(requestUrl, 'http://localhost').search || ''
           res.redirect(302, `${targetPath}${search}`)

package/src/server.js

@@ -530,7 +530,8 @@ export async function startServer (options = {}) {
         if (typeof pageEntry.redirect === 'string' && pageEntry.redirect.trim()) {
           const { language } = resolveRequestLocale(pageRouter, requestUrl, buildDir, config)
           const targetId = pageEntry.redirect.trim().replace(/^@/, '')
-          const targetPath = pageRouter.getPathname({ id: targetId, language })
+          const params = pageRouter.getParamsFromUrl(requestUrl)
+          const targetPath = pageRouter.getPathname({ id: targetId, language, params })
           if (targetPath) {
             const search = new URL(requestUrl, 'http://localhost').search || ''
             res.redirect(302, `${targetPath}${search}`)

package/src/ses/poll-inbound-mail.js

@@ -1,6 +1,7 @@
 import { DeleteMessageCommand, ReceiveMessageCommand, SQSClient } from '@aws-sdk/client-sqs'
 import { GetObjectCommand, S3Client } from '@aws-sdk/client-s3'
 import { fileSesReceipt, sesReceiptFromBody } from '@ossy/email/ses-inbound'
+import { canonicalWorkspaceId } from '@ossy/workspaces/server'
 import { createInProcessSdk } from '../tasks/in-process-sdk.js'
 import { inboundAwsClientConfig } from './inbound-aws-credentials.js'
 
@@ -47,9 +48,12 @@ export function startInboundMailPoller ({ queueUrl, bucket, log } = {}) {
   const file = (body) => fileSesReceipt(sesReceiptFromBody(body), {
     bucket,
     getObject: (location) => readObject(objects, location),
-    invoke: ({ mime, workspaceId }) => createInProcessSdk()
-      .forWorkspace(workspaceId)
-      .invoke(ReceiveInbound, { mime, workspaceId }),
+    invoke: async ({ mime, workspaceId }) => {
+      const canonical = await canonicalWorkspaceId(workspaceId)
+      return createInProcessSdk()
+        .forWorkspace(canonical)
+        .invoke(ReceiveInbound, { mime, workspaceId: canonical })
+    },
   })
 
   const run = (async () => {

package/src/vector/vector-store.js

@@ -2,21 +2,22 @@
  * Vector embedding store backed by MongoDB.
  *
  * Collection: `resource_embeddings`
- * Schema: { resourceId, workspaceId, model, dimensions, vector, textSource, textLength, updatedAt }
+ * Schema: { resourceId, workspaceId, kind, model, dimensions, vector, textSource, textLength, textHash, updatedAt }
  *
  * Search strategy:
  * - If Atlas Vector Search index `resource_embedding_vector` is present → $vectorSearch
- * - Otherwise → in-memory cosine similarity (works fine for <10k resources per workspace)
+ * - Otherwise → cosine similarity over the workspace (and kind, when set)
  *
- * Atlas Vector Search index definition (create via Atlas UI or Admin API):
+ * `workspaceId` and `kind` must be filter fields on that index. A filter on a
+ * field the index does not declare fails the query, and search falls back to
+ * the in-memory scan. Atlas index definition:
  * ```json
  * {
- *   "mappings": {
- *     "dynamic": false,
- *     "fields": {
- *       "vector": { "type": "knnVector", "dimensions": 1536, "similarity": "cosine" }
- *     }
- *   }
+ *   "fields": [
+ *     { "type": "vector", "path": "vector", "numDimensions": 1536, "similarity": "cosine" },
+ *     { "type": "filter", "path": "workspaceId" },
+ *     { "type": "filter", "path": "kind" }
+ *   ]
  * }
  * ```
  */
@@ -67,6 +68,8 @@ function col () {
  *   vector: number[],
  *   textSource: string,
  *   textLength: number,
+ *   kind?: string,
+ *   textHash?: string,
  * }} doc
  */
 export async function upsertEmbedding (doc) {
@@ -97,6 +100,43 @@ export async function deleteEmbedding (resourceId) {
   await col().deleteOne({ resourceId })
 }
 
+/**
+ * Filter for `$vectorSearch` and the in-memory fallback.
+ * `kind` keeps a request vector from matching other requests.
+ *
+ * Atlas `$vectorSearch` filters do not support `$exists`, so the Atlas query
+ * matches `kind` exactly. A changed document writes `kind` when it is embedded
+ * or scored. The in-memory fallback can include legacy rows that predate the field.
+ *
+ * @param {{ workspaceId?: string, kind?: string, includeMissingKind?: boolean }} [scope]
+ */
+export function embeddingSearchFilter ({ workspaceId, kind, includeMissingKind = false } = {}) {
+  const filter = {}
+  if (workspaceId) filter.workspaceId = workspaceId
+  if (!kind) return filter
+  if (!includeMissingKind) {
+    filter.kind = kind
+    return filter
+  }
+  filter.$or = [
+    { kind },
+    { kind: { $exists: false } },
+    { kind: null },
+  ]
+  return filter
+}
+
+/**
+ * Record what a stored vector represents without rewriting the vector.
+ *
+ * @param {string} resourceId
+ * @param {string} kind
+ */
+export async function setEmbeddingKind (resourceId, kind) {
+  if (!resourceId || !kind) return
+  await col().updateOne({ resourceId }, { $set: { kind, updatedAt: new Date() } })
+}
+
 /**
  * Semantic search within a workspace using cosine similarity.
  * Tries Atlas $vectorSearch first; falls back to in-memory similarity.
@@ -106,11 +146,16 @@ export async function deleteEmbedding (resourceId) {
  *   queryVector: number[],
  *   limit?: number,
  *   threshold?: number,
+ *   kind?: string,
  * }} opts
  * @returns {Promise<Array<{ resourceId: string, score: number }>>}
  */
-export async function searchEmbeddings ({ workspaceId, queryVector, limit = 20, threshold = 0 }) {
+export async function searchEmbeddings ({ workspaceId, queryVector, limit = 20, threshold = 0, kind } = {}) {
+  if (!workspaceId || !Array.isArray(queryVector) || !queryVector.length) return []
+  const filter = embeddingSearchFilter({ workspaceId, kind })
+  const capped = Math.max(1, limit)
   // Try Atlas Vector Search (requires index on Atlas M10+).
+  // An empty result is the index answer. A missing index throws and falls back.
   try {
     const pipeline = [
       {
@@ -118,9 +163,9 @@ export async function searchEmbeddings ({ workspaceId, queryVector, limit = 20,
           index: ATLAS_INDEX,
           path: 'vector',
           queryVector,
-          numCandidates: limit * 10,
-          limit,
-          filter: { workspaceId },
+          numCandidates: capped * 10,
+          limit: capped,
+          filter,
         },
       },
       {
@@ -132,17 +177,14 @@ export async function searchEmbeddings ({ workspaceId, queryVector, limit = 20,
       },
     ]
     const results = await col().aggregate(pipeline).toArray()
-    if (results.length > 0) {
-      return results.filter((r) => r.score >= threshold)
-    }
+    return results.filter((r) => r.score >= threshold)
   } catch {
     // Atlas Vector Search not available — fall through to cosine similarity.
   }
 
-  // In-memory cosine similarity fallback.
   log.debug('[VectorStore] Atlas $vectorSearch unavailable — using in-memory cosine similarity')
   const docs = await col()
-    .find({ workspaceId })
+    .find(embeddingSearchFilter({ workspaceId, kind, includeMissingKind: true }))
     .project({ resourceId: 1, vector: 1 })
     .toArray()
 
@@ -153,7 +195,7 @@ export async function searchEmbeddings ({ workspaceId, queryVector, limit = 20,
     }))
     .filter((r) => r.score >= threshold)
     .sort((a, b) => b.score - a.score)
-    .slice(0, limit)
+    .slice(0, capped)
 }
 
 /**
@@ -178,5 +220,6 @@ export async function ensureEmbeddingIndexes () {
   await c.createIndex({ resourceId: 1 }, { name: 'resourceId', unique: true, background: true })
   await c.createIndex({ workspaceId: 1 }, { name: 'workspaceId', background: true })
   await c.createIndex({ workspaceId: 1, updatedAt: -1 }, { name: 'workspaceId_updatedAt', background: true })
+  await c.createIndex({ workspaceId: 1, kind: 1 }, { name: 'workspaceId_kind', background: true })
   log.info('[VectorStore] resource_embeddings indexes ensured')
 }

package/src/vector/vector-store.spec.js

@@ -0,0 +1,35 @@
+import { describe, expect, it, jest } from '@jest/globals'
+
+jest.unstable_mockModule('@ossy/observability', () => ({
+  createLogger: () => ({ debug () {}, info () {}, warn () {}, error () {} }),
+}))
+
+jest.unstable_mockModule('@ossy/event-store', () => ({
+  Mongo: { db: { collection () { return {} } } },
+}))
+
+const { embeddingSearchFilter } = await import('./vector-store.js')
+
+describe('embeddingSearchFilter', () => {
+  it('scopes by workspace and kind for Atlas-compatible filters', () => {
+    expect(embeddingSearchFilter({ workspaceId: 'ws-1', kind: 'resume' })).toEqual({
+      workspaceId: 'ws-1',
+      kind: 'resume',
+    })
+  })
+
+  it('includes legacy rows without kind for the in-memory fallback', () => {
+    expect(embeddingSearchFilter({
+      workspaceId: 'ws-1',
+      kind: 'resume',
+      includeMissingKind: true,
+    })).toEqual({
+      workspaceId: 'ws-1',
+      $or: [
+        { kind: 'resume' },
+        { kind: { $exists: false } },
+        { kind: null },
+      ],
+    })
+  })
+})