@jskit-ai/workspaces-core 0.1.21 → 0.1.23

package/src/shared/resources/workspacePendingInvitationsResource.js

@@ -68,7 +68,7 @@ const pendingInvitationsListOutputValidator = Object.freeze({
 const WORKSPACE_PENDING_INVITATIONS_MESSAGES = createOperationMessages();
 
 const workspacePendingInvitationsResource = Object.freeze({
-  resource: "workspacePendingInvitations",
+  namespace: "workspacePendingInvitations",
   messages: WORKSPACE_PENDING_INVITATIONS_MESSAGES,
   operations: Object.freeze({
     list: Object.freeze({

package/src/shared/resources/workspaceResource.js

@@ -130,7 +130,7 @@ const workspaceSummaryOutputValidator = Object.freeze({
 });
 
 const resource = {
-  resource: "workspace",
+  namespace: "workspace",
   messages: {
     validation: "Fix invalid workspace values and try again.",
     saveSuccess: "Workspace updated.",

package/src/shared/resources/workspaceSettingsFields.js

@@ -17,9 +17,13 @@ function defineField(field = {}) {
   if (!field.outputSchema || typeof field.outputSchema !== "object") {
     throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires outputSchema.`);
   }
-  const dbColumn = normalizeText(field.dbColumn);
-  if (!dbColumn) {
-    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires dbColumn.`);
+  const repository = field?.repository;
+  if (!repository || typeof repository !== "object" || Array.isArray(repository)) {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires repository.column.`);
+  }
+  const repositoryColumn = normalizeText(repository.column);
+  if (!repositoryColumn) {
+    throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires repository.column.`);
   }
   if (typeof field.normalizeInput !== "function") {
     throw new TypeError(`workspaceSettingsFields.defineField("${key}") requires normalizeInput.`);
@@ -33,7 +37,9 @@ function defineField(field = {}) {
 
   workspaceSettingsFields.push({
     key,
-    dbColumn,
+    repository: Object.freeze({
+      column: repositoryColumn
+    }),
     required: field.required !== false,
     inputSchema: field.inputSchema,
     outputSchema: field.outputSchema,

package/src/shared/resources/workspaceSettingsResource.js

@@ -117,7 +117,7 @@ const responseRecordValidator = Object.freeze({
 });
 
 const resource = {
-  resource: "workspaceSettings",
+  namespace: "workspaceSettings",
   messages: {
     validation: "Fix invalid workspace settings values and try again.",
     saveSuccess: "Workspace settings updated.",

package/templates/packages/main/src/shared/resources/workspaceSettingsFields.js

@@ -22,7 +22,7 @@ resetWorkspaceSettingsFields();
 
 defineField({
   key: "lightPrimaryColor",
-  dbColumn: "light_primary_color",
+  repository: { column: "light_primary_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -42,7 +42,7 @@ defineField({
 
 defineField({
   key: "lightSecondaryColor",
-  dbColumn: "light_secondary_color",
+  repository: { column: "light_secondary_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -62,7 +62,7 @@ defineField({
 
 defineField({
   key: "lightSurfaceColor",
-  dbColumn: "light_surface_color",
+  repository: { column: "light_surface_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -82,7 +82,7 @@ defineField({
 
 defineField({
   key: "lightSurfaceVariantColor",
-  dbColumn: "light_surface_variant_color",
+  repository: { column: "light_surface_variant_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -102,7 +102,7 @@ defineField({
 
 defineField({
   key: "darkPrimaryColor",
-  dbColumn: "dark_primary_color",
+  repository: { column: "dark_primary_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -122,7 +122,7 @@ defineField({
 
 defineField({
   key: "darkSecondaryColor",
-  dbColumn: "dark_secondary_color",
+  repository: { column: "dark_secondary_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -142,7 +142,7 @@ defineField({
 
 defineField({
   key: "darkSurfaceColor",
-  dbColumn: "dark_surface_color",
+  repository: { column: "dark_surface_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -162,7 +162,7 @@ defineField({
 
 defineField({
   key: "darkSurfaceVariantColor",
-  dbColumn: "dark_surface_variant_color",
+  repository: { column: "dark_surface_variant_color" },
   required: true,
   inputSchema: Type.String({
     minLength: 7,
@@ -182,7 +182,7 @@ defineField({
 
 defineField({
   key: "invitesEnabled",
-  dbColumn: "invites_enabled",
+  repository: { column: "invites_enabled" },
   required: true,
   inputSchema: Type.Boolean({
     messages: {

package/test/exportsContract.test.js

@@ -14,7 +14,9 @@ test("workspaces-core exports are explicit and aligned with production usage", (
     packageDir: PACKAGE_DIR,
     packageId: "@jskit-ai/workspaces-core",
     requiredExports: [
-      "./server/WorkspacesCoreServiceProvider"
+      "./server/WorkspacesCoreServiceProvider",
+      "./server/validators/routeParamsValidator",
+      "./server/support/workspaceRouteInput"
     ]
   });
 

package/test/registerWorkspaceBootstrap.test.js

@@ -55,7 +55,7 @@ test("registerWorkspaceBootstrap resolves the canonical pending invitations serv
           listPendingInvitesForUser() {}
         };
       }
-      if (token === "usersRepository") {
+      if (token === "internal.repository.user-profiles") {
         return {
           findById() {}
         };

package/test/registerWorkspaceSettings.test.js

@@ -28,7 +28,7 @@ test("registerWorkspaceSettings registers workspace settings service realtime ev
 
   registerWorkspaceSettings(app);
 
-  assert.equal(singletonBindings.has("workspaceSettingsRepository"), true);
+  assert.equal(singletonBindings.has("internal.repository.workspace-settings"), true);
   assert.equal(serviceCalls.length, 1);
   assert.equal(serviceCalls[0].token, "workspaces.settings.service");
   assert.equal(typeof serviceCalls[0].factory, "function");

package/test/usersRouteResources.test.js

@@ -12,7 +12,7 @@ import { workspaceSettingsResource } from "../src/shared/resources/workspaceSett
 function assertResourceShape(resource, label) {
   assert.ok(resource, `${label} resource must exist.`);
   assert.equal(typeof resource, "object", `${label} resource must be an object.`);
-  assert.equal(typeof resource.resource, "string", `${label}.resource must be a string.`);
+  assert.equal(typeof resource.namespace, "string", `.namespace must be a string.`);
 
   for (const operationName of ["view", "list", "create", "replace", "patch"]) {
     const operation = resource.operations?.[operationName];

package/test/workspaceBootstrapContributor.test.js

@@ -35,7 +35,7 @@ test("workspace bootstrap contributor passes actor context to pending invites se
         return [];
       }
     },
-    usersRepository: {
+    userProfilesRepository: {
       async findById() {
         return profile;
       }
@@ -78,7 +78,7 @@ test("workspace bootstrap contributor resolves workspace slug from bootstrap que
         return [];
       }
     },
-    usersRepository: {
+    userProfilesRepository: {
       async findById() {
         return profile;
       }
@@ -123,7 +123,7 @@ test("workspace bootstrap contributor reports unauthenticated requested workspac
         assert.fail("listPendingInvitesForUser should not run for unauthenticated payloads");
       }
     },
-    usersRepository: {
+    userProfilesRepository: {
       async findById() {
         assert.fail("findById should not run for unauthenticated payloads");
       }

package/test/workspaceInvitesRepository.test.js

@@ -1,13 +1,19 @@
 import assert from "node:assert/strict";
 import test from "node:test";
+import { toIsoString, toNullableDateTime } from "@jskit-ai/database-runtime/shared";
 import { createRepository } from "../src/server/common/repositories/workspaceInvitesRepository.js";
 
-function createKnexStub() {
+function createKnexStub({
+  rowById = new Map(),
+  pendingRow = null,
+  joinedRows = []
+} = {}) {
   const state = {
-    insertPayload: null
+    insertPayload: null,
+    updatePayload: null
   };
 
-  const row = {
+  const defaultRow = pendingRow || {
     id: 1,
     workspace_id: 1,
     email: "invitee@example.com",
@@ -23,28 +29,54 @@ function createKnexStub() {
   };
 
   function tableBuilder(tableName) {
+    if (tableName === "workspace_invites as wi") {
+      return {
+        join() {
+          return this;
+        },
+        where() {
+          return this;
+        },
+        orderBy() {
+          return this;
+        },
+        select() {
+          return Promise.resolve([...joinedRows]);
+        }
+      };
+    }
+
     assert.equal(tableName, "workspace_invites");
-    return {
+    const query = {
+      criteriaList: [],
+      select() {
+        return this;
+      },
       insert(payload) {
         state.insertPayload = payload;
         return Promise.resolve([1]);
       },
       where(criteria) {
-        assert.equal(typeof criteria, "object");
-        return {
-          first() {
-            return Promise.resolve({ ...row });
-          },
-          orderBy() {
-            return {
-              first() {
-                return Promise.resolve({ ...row });
-              }
-            };
-          }
-        };
+        this.criteriaList.push(criteria);
+        return this;
+      },
+      orderBy() {
+        return this;
+      },
+      update(payload) {
+        state.updatePayload = payload;
+        return Promise.resolve(1);
+      },
+      first() {
+        const criteria = Object.assign({}, ...this.criteriaList);
+        if (Object.hasOwn(criteria, "id")) {
+          return Promise.resolve(rowById.get(String(criteria.id)) || null);
+        }
+        return Promise.resolve({ ...defaultRow });
       }
     };
+
+    return query;
   }
 
   return { knexStub: tableBuilder, state };
@@ -64,7 +96,7 @@ test("workspaceInvitesRepository.insert normalizes expiresAt ISO input to databa
     expiresAt: "2026-03-16T00:26:35.709Z"
   });
 
-  assert.equal(state.insertPayload.expires_at, "2026-03-16 00:26:35.709");
+  assert.equal(state.insertPayload.expires_at, toNullableDateTime("2026-03-16T00:26:35.709Z"));
 });
 
 test("workspaceInvitesRepository.findPendingByTokenHash reads from invites table without workspace join", async () => {
@@ -90,6 +122,9 @@ test("workspaceInvitesRepository.findPendingByTokenHash reads from invites table
   const repository = createRepository((tableName) => {
     calls.tableName = String(tableName || "");
     return {
+      select() {
+        return this;
+      },
       where(criteria) {
         calls.whereCriteria = criteria;
         return this;
@@ -109,3 +144,79 @@ test("workspaceInvitesRepository.findPendingByTokenHash reads from invites table
   assert.equal(invite?.workspaceId, "9");
   assert.equal(invite?.workspaceSlug, undefined);
 });
+
+test("workspaceInvitesRepository.markAcceptedById uses the internal invite resource for normalized patch writes", async () => {
+  const acceptedRow = {
+    id: 1,
+    workspace_id: 1,
+    email: "invitee@example.com",
+    role_sid: "member",
+    status: "accepted",
+    token_hash: "hash",
+    invited_by_user_id: 1,
+    expires_at: "2026-03-16 00:26:35.709",
+    accepted_at: "2026-03-10 00:26:35.710",
+    revoked_at: null,
+    created_at: "2026-03-09 00:26:35.710",
+    updated_at: "2026-03-10 00:26:35.710"
+  };
+  const { knexStub, state } = createKnexStub({
+    rowById: new Map([["1", acceptedRow]])
+  });
+  const repository = createRepository(knexStub);
+
+  await repository.markAcceptedById("1");
+
+  assert.equal(state.updatePayload.status, "accepted");
+  assert.equal(typeof state.updatePayload.accepted_at, "string");
+  assert.match(state.updatePayload.accepted_at, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/);
+  assert.equal(typeof state.updatePayload.updated_at, "string");
+  assert.match(state.updatePayload.updated_at, /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}$/);
+});
+
+test("workspaceInvitesRepository.listPendingByWorkspaceIdWithWorkspace keeps workspace join fields outside the base resource contract", async () => {
+  const { knexStub } = createKnexStub({
+    joinedRows: [
+      {
+        id: 1,
+        workspace_id: 9,
+        email: "invitee@example.com",
+        role_sid: "member",
+        status: "pending",
+        token_hash: "hash-token",
+        invited_by_user_id: 1,
+        expires_at: "2030-01-01 00:00:00.000",
+        accepted_at: null,
+        revoked_at: null,
+        created_at: "2026-03-09 00:26:35.710",
+        updated_at: "2026-03-09 00:26:35.710",
+        workspace_slug: "tonymobily3",
+        workspace_name: "TonyMobily3",
+        workspace_avatar_url: "https://example.com/avatar.png"
+      }
+    ]
+  });
+  const repository = createRepository(knexStub);
+
+  const invites = await repository.listPendingByWorkspaceIdWithWorkspace("9");
+
+  assert.deepEqual(invites, [
+    {
+      id: "1",
+      workspaceId: "9",
+      email: "invitee@example.com",
+      roleSid: "member",
+      status: "pending",
+      tokenHash: "hash-token",
+      invitedByUserId: "1",
+      expiresAt: toIsoString("2030-01-01 00:00:00.000"),
+      acceptedAt: null,
+      revokedAt: null,
+      createdAt: toIsoString("2026-03-09 00:26:35.710"),
+      updatedAt: toIsoString("2026-03-09 00:26:35.710"),
+      workspaceSlug: "tonymobily3",
+      workspaceName: "TonyMobily3",
+      workspaceAvatarUrl: "https://example.com/avatar.png"
+    }
+  ]);
+});

package/test/workspaceMembershipsRepository.test.js

@@ -0,0 +1,212 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { toIsoString } from "@jskit-ai/database-runtime/shared";
+import { createRepository } from "../src/server/common/repositories/workspaceMembershipsRepository.js";
+
+function createKnexStub({
+  rowById = new Map(),
+  rowByComposite = new Map(),
+  memberSummaryRows = []
+} = {}) {
+  const state = {
+    insertPayload: null,
+    updatePayload: null
+  };
+
+  function buildMembershipsQuery(tableName) {
+    if (tableName === "workspace_memberships as wm") {
+      return {
+        join() {
+          return this;
+        },
+        where() {
+          return this;
+        },
+        orderBy() {
+          return this;
+        },
+        select() {
+          return Promise.resolve([...memberSummaryRows]);
+        }
+      };
+    }
+
+    const query = {
+      criteriaList: [],
+      select() {
+        return this;
+      },
+      insert(payload) {
+        state.insertPayload = payload;
+        const insertedRow = rowById.get("1");
+        if (insertedRow) {
+          rowByComposite.set(`${payload.workspace_id}:${payload.user_id}`, insertedRow);
+        }
+        return Promise.resolve([1]);
+      },
+      where(criteria) {
+        this.criteriaList.push(criteria);
+        return this;
+      },
+      update(payload) {
+        state.updatePayload = payload;
+        const criteria = Object.assign({}, ...this.criteriaList);
+        const existingRow = rowById.get(String(criteria.id));
+        if (existingRow) {
+          const updatedRow = {
+            ...existingRow,
+            ...payload
+          };
+          rowById.set(String(criteria.id), updatedRow);
+          rowByComposite.set(`${updatedRow.workspace_id}:${updatedRow.user_id}`, updatedRow);
+        }
+        return Promise.resolve(1);
+      },
+      first() {
+        const criteria = Object.assign({}, ...this.criteriaList);
+        if (Object.hasOwn(criteria, "id")) {
+          return Promise.resolve(rowById.get(String(criteria.id)) || null);
+        }
+        if (Object.hasOwn(criteria, "workspace_id") && Object.hasOwn(criteria, "user_id")) {
+          return Promise.resolve(
+            rowByComposite.get(`${criteria.workspace_id}:${criteria.user_id}`) || null
+          );
+        }
+        return Promise.resolve(null);
+      }
+    };
+
+    return query;
+  }
+
+  function knex(tableName) {
+    if (tableName === "workspace_memberships" || tableName === "workspace_memberships as wm") {
+      return buildMembershipsQuery(tableName);
+    }
+    throw new Error(`Unexpected table ${tableName}`);
+  }
+
+  knex.transaction = async (work) => work(knex);
+
+  return { knex, state };
+}
+
+test("workspaceMembershipsRepository.findByWorkspaceIdAndUserId normalizes canonical membership rows via the internal resource", async () => {
+  const membershipRow = {
+    id: 11,
+    workspace_id: 7,
+    user_id: 9,
+    role_sid: "owner",
+    status: "active",
+    created_at: "2026-03-09 00:26:35.710",
+    updated_at: "2026-03-10 00:26:35.710"
+  };
+  const { knex } = createKnexStub({
+    rowByComposite: new Map([["7:9", membershipRow]])
+  });
+  const repository = createRepository(knex);
+
+  const membership = await repository.findByWorkspaceIdAndUserId("7", "9");
+
+  assert.deepEqual(membership, {
+    id: "11",
+    workspaceId: "7",
+    userId: "9",
+    roleSid: "owner",
+    status: "active",
+    createdAt: toIsoString("2026-03-09 00:26:35.710"),
+    updatedAt: toIsoString("2026-03-10 00:26:35.710")
+  });
+});
+
+test("workspaceMembershipsRepository.ensureOwnerMembership upgrades an existing membership through the runtime update path", async () => {
+  const existingRow = {
+    id: 11,
+    workspace_id: 7,
+    user_id: 9,
+    role_sid: "member",
+    status: "pending",
+    created_at: "2026-03-09 00:26:35.710",
+    updated_at: "2026-03-09 00:26:35.710"
+  };
+  const refreshedRow = {
+    ...existingRow,
+    role_sid: "owner",
+    status: "active",
+    updated_at: "2026-03-10 00:26:35.710"
+  };
+  const { knex, state } = createKnexStub({
+    rowById: new Map([["11", refreshedRow]]),
+    rowByComposite: new Map([["7:9", existingRow]])
+  });
+  const repository = createRepository(knex);
+
+  const membership = await repository.ensureOwnerMembership("7", "9");
+
+  assert.equal(state.updatePayload.role_sid, "owner");
+  assert.equal(state.updatePayload.status, "active");
+  assert.equal(typeof state.updatePayload.updated_at, "string");
+  assert.deepEqual(membership, {
+    id: "11",
+    workspaceId: "7",
+    userId: "9",
+    roleSid: "owner",
+    status: "active",
+    createdAt: toIsoString("2026-03-09 00:26:35.710"),
+    updatedAt: toIsoString(state.updatePayload.updated_at)
+  });
+});
+
+test("workspaceMembershipsRepository.upsertMembership creates normalized memberships through the runtime create path", async () => {
+  const createdRow = {
+    id: 1,
+    workspace_id: 7,
+    user_id: 9,
+    role_sid: "admin",
+    status: "active",
+    created_at: "2026-03-09 00:26:35.710",
+    updated_at: "2026-03-09 00:26:35.710"
+  };
+  const { knex, state } = createKnexStub({
+    rowById: new Map([["1", createdRow]]),
+    rowByComposite: new Map()
+  });
+  const repository = createRepository(knex);
+
+  await repository.upsertMembership("7", "9", {
+    roleSid: "ADMIN",
+    status: "ACTIVE"
+  });
+
+  assert.equal(state.insertPayload.workspace_id, "7");
+  assert.equal(state.insertPayload.user_id, "9");
+  assert.equal(state.insertPayload.role_sid, "admin");
+  assert.equal(state.insertPayload.status, "active");
+});
+
+test("workspaceMembershipsRepository.listActiveByWorkspaceId keeps summary rows separate from the canonical membership resource", async () => {
+  const { knex } = createKnexStub({
+    memberSummaryRows: [
+      {
+        user_id: 9,
+        role_sid: "owner",
+        status: "active",
+        display_name: "Chiara",
+        email: "CHIARA@example.com"
+      }
+    ]
+  });
+  const repository = createRepository(knex);
+
+  const members = await repository.listActiveByWorkspaceId("7");
+
+  assert.deepEqual(members, [
+    {
+      userId: "9",
+      roleSid: "owner",
+      status: "active",
+      displayName: "Chiara",
+      email: "chiara@example.com"
+    }
+  ]);
+});