@jskit-ai/workspaces-core 0.1.32 → 0.1.34

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/workspaces-core",
-  version: "0.1.32",
+  version: "0.1.34",
   kind: "runtime",
   description: "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
   dependsOn: [
@@ -116,10 +116,10 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/json-rest-api-core": "0.1.1",
-        "@jskit-ai/resource-core": "0.1.1",
-        "@jskit-ai/resource-crud-core": "0.1.1",
-        "@jskit-ai/users-core": "0.1.66"
+        "@jskit-ai/json-rest-api-core": "0.1.3",
+        "@jskit-ai/resource-core": "0.1.3",
+        "@jskit-ai/resource-crud-core": "0.1.3",
+        "@jskit-ai/users-core": "0.1.68"
       },
       dev: {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -17,14 +17,14 @@
     "./shared/resources/workspaceSettingsResource": "./src/shared/resources/workspaceSettingsResource.js"
   },
   "dependencies": {
-    "@jskit-ai/auth-core": "0.1.55",
-    "@jskit-ai/database-runtime": "0.1.56",
-    "@jskit-ai/http-runtime": "0.1.55",
-    "@jskit-ai/json-rest-api-core": "0.1.1",
-    "@jskit-ai/kernel": "0.1.56",
-    "@jskit-ai/resource-crud-core": "0.1.1",
-    "@jskit-ai/resource-core": "0.1.1",
-    "@jskit-ai/users-core": "0.1.66",
+    "@jskit-ai/auth-core": "0.1.57",
+    "@jskit-ai/database-runtime": "0.1.58",
+    "@jskit-ai/http-runtime": "0.1.57",
+    "@jskit-ai/json-rest-api-core": "0.1.3",
+    "@jskit-ai/kernel": "0.1.58",
+    "@jskit-ai/resource-crud-core": "0.1.3",
+    "@jskit-ai/resource-core": "0.1.3",
+    "@jskit-ai/users-core": "0.1.68",
     "json-rest-schema": "1.x.x"
   }
 }

package/src/server/common/repositories/workspaceMembershipsRepository.js

@@ -84,12 +84,19 @@ function createRepository({ api, knex } = {}) {
 
   const withTransaction = createWithTransaction(knex);
 
-  async function queryMemberships(filters = {}, options = {}, { includeUser = false } = {}) {
+  async function queryMemberships(filters = {}, options = {}, { include = [] } = {}) {
+    const normalizedInclude = Array.from(
+      new Set(
+        (Array.isArray(include) ? include : [])
+          .map((entry) => normalizeText(entry))
+          .filter(Boolean)
+      )
+    );
     const result = await api.resources.workspaceMemberships.query(
       {
         queryParams: {
           filters,
-          ...(includeUser ? { include: ["user"] } : {})
+          ...(normalizedInclude.length > 0 ? { include: normalizedInclude } : {})
         },
         transaction: options?.trx || null,
         simplified: false
@@ -263,7 +270,7 @@ function createRepository({ api, knex } = {}) {
         status: "active"
       },
       options,
-      { includeUser: true }
+      { include: ["user"] }
     );
 
     const members = rows

package/src/server/common/services/workspaceContextService.js

@@ -155,7 +155,7 @@ function createService({
     return listWorkspacesForUser(user, options);
   }
 
-  async function provisionWorkspaceForNewUser(user, options = {}) {
+  async function ensureProvisionedWorkspaceForAuthenticatedUser(user, options = {}) {
     const normalizedUserId = normalizeRecordId(user?.id, { fallback: null });
     if (!normalizedUserId) {
       throw new AppError(400, "Invalid authenticated user payload.");
@@ -270,7 +270,7 @@ function createService({
     buildWorkspaceBaseSlug,
     hashInviteToken,
     ensurePersonalWorkspaceForUser,
-    provisionWorkspaceForNewUser,
+    ensureProvisionedWorkspaceForAuthenticatedUser,
     createWorkspaceForAuthenticatedUser,
     getWorkspaceForAuthenticatedUser,
     updateWorkspaceForAuthenticatedUser,

package/src/server/registerWorkspaceCore.js

@@ -67,12 +67,12 @@ function registerWorkspaceCore(app) {
     return Object.freeze({
       contributorId: "workspaces.core.profileSync",
       order: 100,
-      async afterIdentityProfileSynced({ profile, created, options } = {}) {
-        if (!created || !profile || typeof workspaceService?.provisionWorkspaceForNewUser !== "function") {
+      async afterIdentityProfileSynced({ profile, options } = {}) {
+        if (!profile || typeof workspaceService?.ensureProvisionedWorkspaceForAuthenticatedUser !== "function") {
           return;
         }
 
-        await workspaceService.provisionWorkspaceForNewUser(profile, options);
+        await workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser(profile, options);
       }
     });
   });

package/test/workspaceMembershipsRepository.test.js

@@ -48,13 +48,15 @@ function createWorkspaceMembershipsApiStub({
 } = {}) {
   const state = {
     postPayload: null,
-    patchPayload: null
+    patchPayload: null,
+    queryCalls: []
   };
 
   const api = {
     resources: {
       workspaceMemberships: {
         async query({ queryParams }) {
+          state.queryCalls.push(queryParams || {});
           const filters = queryParams?.filters || {};
           const includeUser = Array.isArray(queryParams?.include) && queryParams.include.includes("user");
 
@@ -250,3 +252,23 @@ test("workspaceMembershipsRepository.listActiveByWorkspaceId keeps summary rows
     }
   ]);
 });
+
+test("workspaceMembershipsRepository.listActiveWorkspaceIdsByUserId returns normalized workspace ids from the canonical resource", async () => {
+  const membershipRow = {
+    id: "11",
+    workspace: { id: "7" },
+    user: { id: "9" },
+    roleSid: "owner",
+    status: "active",
+    createdAt: "2026-03-09 00:26:35.710",
+    updatedAt: "2026-03-10 00:26:35.710"
+  };
+  const { api } = createWorkspaceMembershipsApiStub({
+    rowByComposite: new Map([["7:9", membershipRow]])
+  });
+  const repository = createRepository({ api, knex: createKnexStub() });
+
+  const workspaceIds = await repository.listActiveWorkspaceIdsByUserId("9");
+
+  assert.deepEqual(workspaceIds, ["7"]);
+});

package/test/workspaceServerScopeSupport.test.js

@@ -2,6 +2,7 @@ import assert from "node:assert/strict";
 import test from "node:test";
 import { AUTH_POLICY_CONTEXT_RESOLVER_TAG } from "@jskit-ai/auth-core/server/authPolicyContextResolverRegistry";
 import { validateSchemaPayload } from "@jskit-ai/kernel/shared/validators";
+import { PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG } from "@jskit-ai/users-core/server/profileSyncLifecycleContributorRegistry";
 import { createWorkspaceServerScopeSupport } from "../src/server/support/workspaceServerScopeSupport.js";
 import { registerWorkspaceCore } from "../src/server/registerWorkspaceCore.js";
 
@@ -73,3 +74,58 @@ test("registerWorkspaceCore registers the workspace server scope support token",
   assert.equal(typeof support.buildInputFromRouteParams, "function");
   assert.equal(typeof support.resolveWorkspace, "function");
 });
+
+test("registerWorkspaceCore ensures personal workspace provisioning on every authenticated profile sync", async () => {
+  const singletons = new Map();
+  const tags = new Map();
+  const app = {
+    singleton(token, factory) {
+      singletons.set(token, factory);
+      return this;
+    },
+    tag(token, tagName) {
+      const key = String(tagName || "");
+      const list = tags.get(key) || [];
+      list.push(String(token || ""));
+      tags.set(key, list);
+      return this;
+    },
+    has() {
+      return false;
+    }
+  };
+
+  registerWorkspaceCore(app);
+
+  assert.deepEqual(tags.get(PROFILE_SYNC_LIFECYCLE_CONTRIBUTOR_TAG), ["workspaces.core.profileSyncLifecycleContributor"]);
+
+  const lifecycleFactory = singletons.get("workspaces.core.profileSyncLifecycleContributor");
+  assert.equal(typeof lifecycleFactory, "function");
+
+  const calls = [];
+  const contributor = lifecycleFactory({
+    make(token) {
+      if (token === "workspaces.service") {
+        return {
+          async ensureProvisionedWorkspaceForAuthenticatedUser(profile, options = {}) {
+            calls.push({ profile, options });
+          }
+        };
+      }
+      throw new Error(`Unexpected token: ${token}`);
+    }
+  });
+
+  await contributor.afterIdentityProfileSynced({
+    profile: { id: "7", username: "tonymobily" },
+    created: false,
+    options: { trx: { id: "tx-1" } }
+  });
+
+  assert.deepEqual(calls, [
+    {
+      profile: { id: "7", username: "tonymobily" },
+      options: { trx: { id: "tx-1" } }
+    }
+  ]);
+});

package/test/workspaceService.test.js

@@ -41,7 +41,8 @@ function createWorkspaceServiceFixture({
     listForUserId: 0,
     insert: 0,
     updateById: 0,
-    ensureOwnerMembership: 0
+    ensureOwnerMembership: 0,
+    ensureWorkspaceSettings: 0
   };
   let nextWorkspaceId = 10;
   const personalWorkspaceState =
@@ -167,6 +168,7 @@ function createWorkspaceServiceFixture({
     },
     workspaceSettingsRepository: {
       async ensureForWorkspaceId() {
+        calls.ensureWorkspaceSettings += 1;
         return {
           invitesEnabled: true
         };
@@ -258,13 +260,13 @@ test("workspaceService.listWorkspacesForUser returns all active memberships in p
   assert.equal(calls.listForUserId, 1);
 });
 
-test("workspaceService.provisionWorkspaceForNewUser provisions personal workspace only in personal tenancy", async () => {
+test("workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser provisions personal workspace only in personal tenancy", async () => {
   const { service, calls, insertedPayloads } = createWorkspaceServiceFixture({
     tenancyMode: "personal",
     personalWorkspace: null
   });
 
-  const workspace = await service.provisionWorkspaceForNewUser({
+  const workspace = await service.ensureProvisionedWorkspaceForAuthenticatedUser({
     id: "7",
     email: "chiaramobily@gmail.com",
     displayName: "Chiara"
@@ -274,15 +276,34 @@ test("workspaceService.provisionWorkspaceForNewUser provisions personal workspac
   assert.equal(calls.findPersonalByOwnerUserId, 1);
   assert.equal(calls.insert, 1);
   assert.equal(calls.ensureOwnerMembership, 1);
+  assert.equal(calls.ensureWorkspaceSettings, 1);
   assert.equal(insertedPayloads[0].isPersonal, true);
 });
 
-test("workspaceService.provisionWorkspaceForNewUser is a no-op outside personal tenancy", async () => {
+test("workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser reuses the existing personal workspace in personal tenancy", async () => {
+  const { service, calls } = createWorkspaceServiceFixture({
+    tenancyMode: "personal"
+  });
+
+  const workspace = await service.ensureProvisionedWorkspaceForAuthenticatedUser({
+    id: "7",
+    email: "chiaramobily@gmail.com",
+    displayName: "Chiara"
+  });
+
+  assert.equal(workspace.id, "1");
+  assert.equal(calls.findPersonalByOwnerUserId, 1);
+  assert.equal(calls.insert, 0);
+  assert.equal(calls.ensureOwnerMembership, 1);
+  assert.equal(calls.ensureWorkspaceSettings, 1);
+});
+
+test("workspaceService.ensureProvisionedWorkspaceForAuthenticatedUser is a no-op outside personal tenancy", async () => {
   const { service, calls } = createWorkspaceServiceFixture({
     tenancyMode: "workspaces"
   });
 
-  const result = await service.provisionWorkspaceForNewUser({
+  const result = await service.ensureProvisionedWorkspaceForAuthenticatedUser({
     id: "7",
     email: "chiaramobily@gmail.com",
     displayName: "Chiara"