@jskit-ai/workspaces-core 0.1.30 → 0.1.32

package/test/workspacesRepository.test.js

@@ -3,129 +3,190 @@ import test from "node:test";
 import { toIsoString } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "../src/server/common/repositories/workspacesRepository.js";
 
-function createWorkspacesKnexStub({
-  rowById = new Map(),
-  rowBySlug = new Map(),
-  insertError = null,
-  membershipRows = []
+function createKnexStub() {
+  return Object.assign(() => {
+    throw new Error("query execution not expected");
+  }, {
+    async transaction(work) {
+      return work({ trxId: "trx-1" });
+    }
+  });
+}
+
+function toWorkspaceResource(row = {}) {
+  return {
+    type: "workspaces",
+    id: String(row.id || ""),
+    attributes: {
+      slug: row.slug,
+      name: row.name,
+      isPersonal: row.isPersonal,
+      avatarUrl: row.avatarUrl,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      deletedAt: row.deletedAt
+    },
+    relationships: {
+      owner: {
+        data: row.ownerUserId == null
+          ? null
+          : {
+              type: "userProfiles",
+              id: String(row.ownerUserId)
+            }
+      }
+    }
+  };
+}
+
+function toWorkspaceMembershipResource(row = {}) {
+  return {
+    type: "workspaceMemberships",
+    id: String(row.id || ""),
+    attributes: {
+      roleSid: row.roleSid,
+      status: row.status,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt
+    },
+    relationships: {
+      user: {
+        data: row?.user?.id == null ? null : { type: "userProfiles", id: String(row.user.id) }
+      },
+      workspace: {
+        data: row?.workspace?.id == null ? null : { type: "workspaces", id: String(row.workspace.id) }
+      }
+    }
+  };
+}
+
+function createWorkspacesApiStub({
+  rowsById = new Map(),
+  rowsBySlug = new Map(),
+  personalRowsByOwnerId = new Map(),
+  membershipRows = [],
+  insertError = null
 } = {}) {
   const state = {
-    insertPayload: null,
-    updatePayload: null
+    postPayload: null,
+    patchPayload: null
   };
 
-  function buildWorkspacesQuery(tableName) {
-    const query = {
-      tableName,
-      selectedColumns: [],
-      whereCriteria: [],
-      orderByClauses: [],
-      select(...columns) {
-        this.selectedColumns = columns;
-        return this;
-      },
-      where(criteria) {
-        this.whereCriteria.push(criteria);
-        return this;
-      },
-      orderBy(column, direction) {
-        this.orderByClauses.push({ column, direction });
-        return this;
-      },
-      async first() {
-        const criteria = Object.assign({}, ...this.whereCriteria);
-        if (Object.hasOwn(criteria, "w.id")) {
-          return rowById.get(String(criteria["w.id"])) || null;
-        }
-        if (Object.hasOwn(criteria, "id")) {
-          return rowById.get(String(criteria.id)) || null;
-        }
-        if (Object.hasOwn(criteria, "w.slug")) {
-          return rowBySlug.get(String(criteria["w.slug"])) || null;
-        }
-        if (Object.hasOwn(criteria, "w.owner_user_id") && Object.hasOwn(criteria, "w.is_personal")) {
-          for (const row of rowById.values()) {
-            if (
-              String(row.owner_user_id) === String(criteria["w.owner_user_id"]) &&
-              Number(row.is_personal) === Number(criteria["w.is_personal"])
-            ) {
-              return row;
-            }
+  const api = {
+    resources: {
+      workspaces: {
+        async query({ queryParams }) {
+          const filters = queryParams?.filters || {};
+
+          if (Object.hasOwn(filters, "id")) {
+            const row = rowsById.get(String(filters.id)) || null;
+            return { data: row ? [toWorkspaceResource(row)] : [] };
           }
-        }
-        return null;
-      },
-      async insert(payload) {
-        state.insertPayload = payload;
-        if (insertError) {
-          throw insertError;
-        }
-        return [1];
-      },
-      async update(payload) {
-        state.updatePayload = payload;
-        return 1;
-      }
-    };
 
-    return query;
-  }
+          if (Object.hasOwn(filters, "slug")) {
+            const row = rowsBySlug.get(String(filters.slug)) || null;
+            return { data: row ? [toWorkspaceResource(row)] : [] };
+          }
 
-  function buildMembershipsQuery() {
-    return {
-      join() {
-        return this;
-      },
-      where() {
-        return this;
-      },
-      whereNull() {
-        return this;
-      },
-      orderBy() {
-        return this;
+          if (Object.hasOwn(filters, "owner") && Object.hasOwn(filters, "isPersonal")) {
+            const rows = personalRowsByOwnerId.get(String(filters.owner)) || [];
+            return { data: rows.map((row) => toWorkspaceResource(row)) };
+          }
+
+          return { data: [] };
+        },
+        async post(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          state.postPayload = inputRecord;
+          if (insertError) {
+            throw insertError;
+          }
+
+          const row = {
+            id: "1",
+            slug: String(inputRecord.attributes?.slug || ""),
+            name: String(inputRecord.attributes?.name || ""),
+            ownerUserId: String(inputRecord.relationships?.owner?.data?.id || ""),
+            isPersonal: Boolean(inputRecord.attributes?.isPersonal),
+            avatarUrl: String(inputRecord.attributes?.avatarUrl || ""),
+            createdAt: inputRecord.attributes?.createdAt,
+            updatedAt: inputRecord.attributes?.updatedAt,
+            deletedAt: null
+          };
+          rowsById.set(row.id, row);
+          if (row.slug) {
+            rowsBySlug.set(row.slug, row);
+          }
+          return { data: toWorkspaceResource(row) };
+        },
+        async patch(payload) {
+          assert.equal(payload?.simplified, false);
+          const inputRecord = payload?.inputRecord?.data || {};
+          state.patchPayload = inputRecord;
+          const existing = rowsById.get(String(inputRecord.id)) || {
+            id: String(inputRecord.id)
+          };
+          const updated = {
+            ...existing,
+            ...(inputRecord.attributes || {}),
+            ...(inputRecord.relationships?.owner?.data?.id
+              ? { ownerUserId: String(inputRecord.relationships.owner.data.id) }
+              : {}),
+            id: String(inputRecord.id)
+          };
+          rowsById.set(updated.id, updated);
+          if (updated.slug) {
+            rowsBySlug.set(String(updated.slug), updated);
+          }
+          return { data: toWorkspaceResource(updated) };
+        }
       },
-      select() {
-        return Promise.resolve([...membershipRows]);
-      }
-    };
-  }
+      workspaceMemberships: {
+        async query({ queryParams }) {
+          const filters = queryParams?.filters || {};
+          const includeWorkspace = Array.isArray(queryParams?.include) && queryParams.include.includes("workspace");
+          if (Object.hasOwn(filters, "user") && Object.hasOwn(filters, "status")) {
+            const rows = membershipRows.filter((row) => (
+              String(row?.user?.id || "") === String(filters.user) &&
+              String(row?.status || "") === String(filters.status)
+            ));
+            return {
+              data: rows.map((row) => toWorkspaceMembershipResource(row)),
+              included: includeWorkspace
+                ? rows
+                    .filter((row) => row?.workspace?.id != null)
+                    .map((row) => toWorkspaceResource(row.workspace))
+                : []
+            };
+          }
 
-  function knex(tableName) {
-    if (tableName === "workspaces" || tableName === "workspaces as w") {
-      return buildWorkspacesQuery(tableName);
-    }
-    if (tableName === "workspace_memberships as wm") {
-      return buildMembershipsQuery();
+          return { data: [] };
+        }
+      }
     }
-    throw new Error(`Unexpected table ${tableName}`);
-  }
-
-  knex.transaction = async (work) => work(knex);
+  };
 
-  return { knex, state };
+  return { api, state };
 }
 
-test("workspacesRepository.findById normalizes internal workspace fields via the internal resource", async () => {
-  const { knex } = createWorkspacesKnexStub({
-    rowById: new Map([
-      [
-        "7",
-        {
-          id: 7,
-          slug: "tonymobily3",
-          name: "TonyMobily3",
-          owner_user_id: 9,
-          is_personal: 1,
-          avatar_url: "",
-          created_at: "2026-03-09 00:26:35.710",
-          updated_at: "2026-03-10 00:26:35.710",
-          deleted_at: null
-        }
-      ]
+test("workspacesRepository.findById reads a canonical workspace row through json-rest-api", async () => {
+  const { api } = createWorkspacesApiStub({
+    rowsById: new Map([
+      ["7", {
+        id: "7",
+        slug: "tonymobily3",
+        name: "TonyMobily3",
+        ownerUserId: "9",
+        isPersonal: true,
+        avatarUrl: "",
+        createdAt: "2026-03-09 00:26:35.710",
+        updatedAt: "2026-03-10 00:26:35.710",
+        deletedAt: null
+      }]
     ])
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const workspace = await repository.findById("7");
 
@@ -142,75 +203,83 @@ test("workspacesRepository.findById normalizes internal workspace fields via the
   });
 });
 
-test("workspacesRepository.findPersonalByOwnerUserId returns null when no personal workspace exists", async () => {
-  const { knex } = createWorkspacesKnexStub();
-  const repository = createRepository(knex);
+test("workspacesRepository.findPersonalByOwnerUserId returns the first personal workspace by canonical id order", async () => {
+  const { api } = createWorkspacesApiStub({
+    personalRowsByOwnerId: new Map([
+      ["9", [
+        {
+          id: "12",
+          slug: "later-workspace",
+          name: "Later Workspace",
+          ownerUserId: "9",
+          isPersonal: true,
+          avatarUrl: "",
+          createdAt: "2026-03-09 00:26:35.710",
+          updatedAt: "2026-03-09 00:26:35.710",
+          deletedAt: null
+        },
+        {
+          id: "7",
+          slug: "first-workspace",
+          name: "First Workspace",
+          ownerUserId: "9",
+          isPersonal: true,
+          avatarUrl: "",
+          createdAt: "2026-03-08 00:26:35.710",
+          updatedAt: "2026-03-08 00:26:35.710",
+          deletedAt: null
+        }
+      ]]
+    ])
+  });
+  const repository = createRepository({ api, knex: createKnexStub() });
 
-  const workspace = await repository.findPersonalByOwnerUserId("999");
+  const workspace = await repository.findPersonalByOwnerUserId("9");
 
-  assert.equal(workspace, null);
+  assert.equal(workspace?.id, "7");
+  assert.equal(workspace?.slug, "first-workspace");
 });
 
-test("workspacesRepository.insert uses runtime normalization and timestamp columns", async () => {
-  const insertedRow = {
-    id: 1,
-    slug: "tonymobily3",
-    name: "TonyMobily3",
-    owner_user_id: 9,
-    is_personal: 0,
-    avatar_url: "",
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-09 00:26:35.710",
-    deleted_at: null
-  };
-  const { knex, state } = createWorkspacesKnexStub({
-    rowById: new Map([["1", insertedRow]])
-  });
-  const repository = createRepository(knex);
+test("workspacesRepository.insert writes canonical fields through json-rest-api", async () => {
+  const { api, state } = createWorkspacesApiStub();
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const inserted = await repository.insert({
     slug: "TonyMobily3",
     name: "TonyMobily3",
-    ownerUserId: "9"
-  });
-
-  assert.equal(state.insertPayload.slug, "tonymobily3");
-  assert.equal(state.insertPayload.name, "TonyMobily3");
-  assert.equal(state.insertPayload.owner_user_id, "9");
-  assert.equal(state.insertPayload.is_personal, false);
-  assert.equal(state.insertPayload.avatar_url, "");
-  assert.equal(typeof state.insertPayload.created_at, "string");
-  assert.equal(typeof state.insertPayload.updated_at, "string");
-  assert.deepEqual(inserted, {
-    id: "1",
-    slug: "tonymobily3",
-    name: "TonyMobily3",
     ownerUserId: "9",
-    isPersonal: false,
     avatarUrl: "",
-    createdAt: toIsoString("2026-03-09 00:26:35.710"),
-    updatedAt: toIsoString("2026-03-09 00:26:35.710"),
-    deletedAt: null
+    isPersonal: false
   });
+
+  assert.equal(state.postPayload.relationships?.owner?.data?.id, "9");
+  assert.equal(state.postPayload.attributes?.slug, "TonyMobily3");
+  assert.equal(state.postPayload.attributes?.name, "TonyMobily3");
+  assert.equal(state.postPayload.attributes?.isPersonal, false);
+  assert.equal(state.postPayload.attributes?.avatarUrl, "");
+  assert.equal(typeof state.postPayload.attributes?.createdAt, "object");
+  assert.equal(typeof state.postPayload.attributes?.updatedAt, "object");
+  assert.equal(inserted.id, "1");
+  assert.equal(inserted.ownerUserId, "9");
 });
 
-test("workspacesRepository.insert falls back to slug lookup on duplicate workspace slug", async () => {
+test("workspacesRepository.insert falls back to slug lookup on duplicate slug", async () => {
   const existingRow = {
-    id: 12,
+    id: "12",
     slug: "shared-workspace",
     name: "Shared Workspace",
-    owner_user_id: 9,
-    is_personal: 0,
-    avatar_url: "",
-    created_at: "2026-03-09 00:26:35.710",
-    updated_at: "2026-03-09 00:26:35.710",
-    deleted_at: null
+    ownerUserId: "9",
+    isPersonal: false,
+    avatarUrl: "",
+    createdAt: "2026-03-09 00:26:35.710",
+    updatedAt: "2026-03-09 00:26:35.710",
+    deletedAt: null
   };
-  const { knex } = createWorkspacesKnexStub({
-    rowBySlug: new Map([["shared-workspace", existingRow]]),
+  const { api } = createWorkspacesApiStub({
+    rowsBySlug: new Map([["shared-workspace", existingRow]]),
     insertError: { code: "ER_DUP_ENTRY" }
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
   const inserted = await repository.insert({
     slug: "shared-workspace",
@@ -222,29 +291,91 @@ test("workspacesRepository.insert falls back to slug lookup on duplicate workspa
   assert.equal(inserted?.slug, "shared-workspace");
 });
 
-test("workspacesRepository.listForUserId keeps membership-specific fields while normalizing workspace fields", async () => {
-  const { knex } = createWorkspacesKnexStub({
-    membershipRows: [
-      {
-        id: 7,
+test("workspacesRepository.updateById patches canonical fields and updatedAt", async () => {
+  const { api, state } = createWorkspacesApiStub({
+    rowsById: new Map([
+      ["7", {
+        id: "7",
         slug: "tonymobily3",
         name: "TonyMobily3",
-        owner_user_id: 9,
-        is_personal: 1,
-        avatar_url: "",
-        created_at: "2026-03-09 00:26:35.710",
-        updated_at: "2026-03-10 00:26:35.710",
-        deleted_at: null,
-        role_sid: "owner",
-        membership_status: "active"
+        ownerUserId: "9",
+        isPersonal: false,
+        avatarUrl: "",
+        createdAt: "2026-03-09 00:26:35.710",
+        updatedAt: "2026-03-09 00:26:35.710",
+        deletedAt: null
+      }]
+    ])
+  });
+  const repository = createRepository({ api, knex: createKnexStub() });
+
+  await repository.updateById("7", {
+    name: "TonyMobily 4"
+  });
+
+  assert.equal(state.patchPayload.id, "7");
+  assert.equal(state.patchPayload.attributes?.name, "TonyMobily 4");
+  assert.equal(typeof state.patchPayload.attributes?.updatedAt, "object");
+});
+
+test("workspacesRepository.listForUserId keeps membership fields outside the canonical workspace row", async () => {
+  const { api } = createWorkspacesApiStub({
+    membershipRows: [
+      {
+        user: { id: "9" },
+        roleSid: "owner",
+        status: "active",
+        workspace: {
+          id: "7",
+          slug: "tonymobily3",
+          name: "TonyMobily3",
+          ownerUserId: "9",
+          isPersonal: true,
+          avatarUrl: "",
+          createdAt: "2026-03-09 00:26:35.710",
+          updatedAt: "2026-03-10 00:26:35.710",
+          deletedAt: null
+        }
+      },
+      {
+        user: { id: "9" },
+        roleSid: "member",
+        status: "active",
+        workspace: {
+          id: "8",
+          slug: "team-space",
+          name: "Team Space",
+          ownerUserId: "10",
+          isPersonal: false,
+          avatarUrl: "",
+          createdAt: "2026-03-09 00:26:35.710",
+          updatedAt: "2026-03-10 00:26:35.710",
+          deletedAt: null
+        }
+      },
+      {
+        user: { id: "9" },
+        roleSid: "member",
+        status: "active",
+        workspace: {
+          id: "9",
+          slug: "deleted-space",
+          name: "Deleted Space",
+          ownerUserId: "10",
+          isPersonal: false,
+          avatarUrl: "",
+          createdAt: "2026-03-09 00:26:35.710",
+          updatedAt: "2026-03-10 00:26:35.710",
+          deletedAt: "2026-03-11 00:26:35.710"
+        }
       }
     ]
   });
-  const repository = createRepository(knex);
+  const repository = createRepository({ api, knex: createKnexStub() });
 
-  const rows = await repository.listForUserId("9");
+  const workspaces = await repository.listForUserId("9");
 
-  assert.deepEqual(rows, [
+  assert.deepEqual(workspaces, [
     {
       id: "7",
       slug: "tonymobily3",
@@ -257,6 +388,19 @@ test("workspacesRepository.listForUserId keeps membership-specific fields while
       deletedAt: null,
       roleSid: "owner",
       membershipStatus: "active"
+    },
+    {
+      id: "8",
+      slug: "team-space",
+      name: "Team Space",
+      ownerUserId: "10",
+      isPersonal: false,
+      avatarUrl: "",
+      createdAt: toIsoString("2026-03-09 00:26:35.710"),
+      updatedAt: toIsoString("2026-03-10 00:26:35.710"),
+      deletedAt: null,
+      roleSid: "member",
+      membershipStatus: "active"
     }
   ]);
 });

package/test/workspacesRouteRequestInputValidator.test.js

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { UsersCoreServiceProvider } from "../../users-core/src/server/UsersCoreServiceProvider.js";
+import { INTERNAL_JSON_REST_API } from "../../json-rest-api-core/src/server/jsonRestApiHost.js";
 import { resolveTenancyProfile } from "../src/shared/tenancyProfile.js";
 import { WorkspacesCoreServiceProvider } from "../src/server/WorkspacesCoreServiceProvider.js";
 
@@ -36,6 +37,13 @@ async function registerRoutes({
   workspaceInvitationsEnabled = true,
   workspaceSelfCreateEnabled = true
 } = {}) {
+  const internalApi = {
+    resources: {},
+    async addResource(scopeName) {
+      this.resources[scopeName] = {};
+      return this.resources[scopeName];
+    }
+  };
   const registeredRoutes = [];
   const router = {
     register(method, path, route, handler) {
@@ -51,6 +59,7 @@ async function registerRoutes({
   const bindings = new Map([
     ["jskit.http.router", router],
     ["authService", authService],
+    [INTERNAL_JSON_REST_API, internalApi],
     [
       "users.accountProfile.service",
       {
@@ -77,6 +86,10 @@ async function registerRoutes({
     has(token) {
       return bindings.has(token);
     },
+    instance(token, value) {
+      bindings.set(token, value);
+      return this;
+    },
     make(token) {
       if (!bindings.has(token)) {
         throw new Error(`Missing test binding for token: ${String(token)}`);
@@ -121,7 +134,7 @@ function createActionRequest({ input = {}, executeAction, file = null }) {
   };
 }
 
-test("workspace and settings routes attach only the shared transport normalizers they actually use", async () => {
+test("workspace and settings routes attach only shared schema definitions on raw route contracts", async () => {
   const routes = await registerRoutes();
 
   const workspaceSettings = findRoute(routes, {
@@ -149,13 +162,13 @@ test("workspace and settings routes attach only the shared transport normalizers
     path: "/api/w/:workspaceSlug/invites/:inviteId"
   });
 
-  assert.equal(typeof workspaceSettings?.paramsValidator?.normalize, "function");
-  assert.equal(typeof workspacePatch?.bodyValidator?.normalize, "function");
-  assert.equal(typeof workspaceSettingsPatch?.bodyValidator?.normalize, "function");
-  assert.equal(typeof workspaceMemberRole?.paramsValidator?.normalize, "function");
-  assert.equal(typeof workspaceMemberRole?.bodyValidator?.normalize, "function");
-  assert.equal(typeof workspaceMemberDelete?.paramsValidator?.normalize, "function");
-  assert.equal(typeof workspaceInviteDelete?.paramsValidator?.normalize, "function");
+  assert.equal(typeof workspaceSettings?.params?.schema, "object");
+  assert.equal(typeof workspacePatch?.body?.schema, "object");
+  assert.equal(typeof workspaceSettingsPatch?.body?.schema, "object");
+  assert.equal(typeof workspaceMemberRole?.params?.schema, "object");
+  assert.equal(typeof workspaceMemberRole?.body?.schema, "object");
+  assert.equal(typeof workspaceMemberDelete?.params?.schema, "object");
+  assert.equal(typeof workspaceInviteDelete?.params?.schema, "object");
 });
 
 test("workspace core/settings routes mount one canonical workspace endpoint", async () => {
@@ -405,7 +418,7 @@ test("workspace invite and member handlers build action input from request.input
     actionId: "workspace.workspaces.create",
     input: { name: "Operations", slug: "operations" }
   });
-  assert.deepEqual(calls[1].input, { payload: { token: "token-1", decision: "accept" } });
+  assert.deepEqual(calls[1].input, { token: "token-1", decision: "accept" });
   assert.deepEqual(calls[2].input, { workspaceSlug: "acme", memberUserId: "12", roleSid: "admin" });
   assert.deepEqual(calls[3].input, { workspaceSlug: "acme", email: "user@example.com", roleSid: "member" });
   assert.deepEqual(calls[4].input, { workspaceSlug: "acme", memberUserId: "44" });
@@ -437,7 +450,7 @@ test("workspace settings route handlers build action input from request.input",
 
   assert.deepEqual(calls[0], {
     actionId: "workspace.settings.update",
-    input: { workspaceSlug: "acme", patch: { lightPrimaryColor: "#0F6B54" } }
+    input: { workspaceSlug: "acme", lightPrimaryColor: "#0F6B54" }
   });
 });
 
@@ -468,7 +481,8 @@ test("workspace route handlers build action input from request.input", async ()
     actionId: "workspace.workspaces.update",
     input: {
       workspaceSlug: "acme",
-      patch: { name: "Acme", avatarUrl: "https://example.com/acme.png" }
+      name: "Acme",
+      avatarUrl: "https://example.com/acme.png"
     }
   });
 });