@jskit-ai/workspaces-core 0.1.31 → 0.1.32

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

@@ -1,27 +1,50 @@
-import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
+  createWithTransaction,
   normalizeLowerText,
   normalizeRecordId,
   normalizeDbRecordId,
   normalizeText,
-  isDuplicateEntryError
+  isDuplicateEntryError,
+  toIsoString
 } from "./repositoryUtils.js";
+import {
+  createJsonApiInputRecord,
+  createJsonApiRelationship,
+  createJsonRestContext,
+  simplifyJsonApiDocument
+} from "@jskit-ai/json-rest-api-core/server/jsonRestApiHost";
 import { OWNER_ROLE_ID } from "../../../shared/roles.js";
-import { workspaceMembershipsResource } from "../resources/workspaceMembershipsResource.js";
 
-const REPOSITORY_CONFIG = Object.freeze({
-  context: "internal.repository.workspace-memberships"
-});
+const RESOURCE_TYPE = "workspaceMemberships";
 
 function normalizeMembershipRecord(payload) {
   if (!payload) {
     return null;
   }
-  return workspaceMembershipsResource.operations.view.outputValidator.normalize(payload);
+
+  return {
+    id: normalizeDbRecordId(payload.id, { fallback: null }),
+    workspaceId: normalizeDbRecordId(payload?.workspace?.id || payload?.workspaceId, { fallback: null }),
+    userId: normalizeDbRecordId(payload?.user?.id || payload?.userId, { fallback: null }),
+    roleSid: normalizeLowerText(payload.roleSid || "member") || "member",
+    status: normalizeLowerText(payload.status || "active") || "active",
+    createdAt: payload.createdAt ? toIsoString(payload.createdAt) : null,
+    updatedAt: payload.updatedAt ? toIsoString(payload.updatedAt) : null
+  };
 }
 
 function normalizeMembershipPatchPayload(payload = {}) {
-  return workspaceMembershipsResource.operations.patch.bodyValidator.normalize(payload);
+  const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const normalized = {};
+
+  if (Object.hasOwn(source, "roleSid")) {
+    normalized.roleSid = normalizeLowerText(source.roleSid);
+  }
+  if (Object.hasOwn(source, "status")) {
+    normalized.status = normalizeLowerText(source.status);
+  }
+
+  return normalized;
 }
 
 function normalizeMemberSummaryRow(row) {
@@ -38,12 +61,44 @@ function normalizeMemberSummaryRow(row) {
   };
 }
 
-function createRepository(knex) {
+function createMembershipRelationships({ workspaceId = null, userId = null } = {}) {
+  const relationships = {};
+
+  if (workspaceId) {
+    relationships.workspace = createJsonApiRelationship("workspaces", workspaceId);
+  }
+  if (userId) {
+    relationships.user = createJsonApiRelationship("userProfiles", userId);
+  }
+
+  return relationships;
+}
+
+function createRepository({ api, knex } = {}) {
+  if (!api?.resources?.workspaceMemberships) {
+    throw new TypeError("workspaceMembershipsRepository requires json-rest-api workspaceMemberships resource.");
+  }
   if (typeof knex !== "function") {
     throw new TypeError("workspaceMembershipsRepository requires knex.");
   }
-  const resourceRuntime = createCrudResourceRuntime(workspaceMembershipsResource, knex, REPOSITORY_CONFIG);
-  const withTransaction = resourceRuntime.withTransaction;
+
+  const withTransaction = createWithTransaction(knex);
+
+  async function queryMemberships(filters = {}, options = {}, { includeUser = false } = {}) {
+    const result = await api.resources.workspaceMemberships.query(
+      {
+        queryParams: {
+          filters,
+          ...(includeUser ? { include: ["user"] } : {})
+        },
+        transaction: options?.trx || null,
+        simplified: false
+      },
+      createJsonRestContext(options?.context || null)
+    );
+
+    return Array.isArray(simplifyJsonApiDocument(result)) ? simplifyJsonApiDocument(result) : [];
+  }
 
   async function findByWorkspaceIdAndUserId(workspaceId, userId, options = {}) {
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
@@ -52,11 +107,15 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    const row = await client("workspace_memberships")
-      .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
-      .first();
-    return normalizeMembershipRecord(row);
+    const rows = await queryMemberships(
+      {
+        workspace: normalizedWorkspaceId,
+        user: normalizedUserId
+      },
+      options
+    );
+
+    return normalizeMembershipRecord(rows[0] || null);
   }
 
   async function ensureOwnerMembership(workspaceId, userId, options = {}) {
@@ -66,40 +125,53 @@ function createRepository(knex) {
       throw new TypeError("workspaceMembershipsRepository.ensureOwnerMembership requires workspaceId and userId.");
     }
 
-    const client = options?.trx || knex;
-    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
+    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
     if (existing) {
       if (existing.roleSid !== OWNER_ROLE_ID || existing.status !== "active") {
-        await resourceRuntime.updateById(
-          existing.id,
+        await api.resources.workspaceMemberships.patch(
           {
-            roleSid: OWNER_ROLE_ID,
-            status: "active"
+            inputRecord: createJsonApiInputRecord(
+              RESOURCE_TYPE,
+              {
+                roleSid: OWNER_ROLE_ID,
+                status: "active",
+                updatedAt: new Date()
+              },
+              {
+                id: existing.id
+              }
+            ),
+            transaction: options?.trx || null,
+            simplified: false
           },
-          {
-            ...options,
-            trx: client,
-            include: "none",
-            existingRecord: existing
-          }
+          createJsonRestContext(options?.context || null)
         );
       }
-      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
+      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
     }
 
     try {
-      await resourceRuntime.create(
+      await api.resources.workspaceMemberships.post(
         {
-          workspaceId: normalizedWorkspaceId,
-          userId: normalizedUserId,
-          roleSid: OWNER_ROLE_ID,
-          status: "active"
+          inputRecord: createJsonApiInputRecord(
+            RESOURCE_TYPE,
+            {
+              roleSid: OWNER_ROLE_ID,
+              status: "active",
+              createdAt: new Date(),
+              updatedAt: new Date()
+            },
+            {
+              relationships: createMembershipRelationships({
+                workspaceId: normalizedWorkspaceId,
+                userId: normalizedUserId
+              })
+            }
+          ),
+          transaction: options?.trx || null,
+          simplified: false
         },
-        {
-          ...options,
-          trx: client,
-          include: "none"
-        }
+        createJsonRestContext(options?.context || null)
       );
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
@@ -107,7 +179,7 @@ function createRepository(knex) {
       }
     }
 
-    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
+    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
   }
 
   async function upsertMembership(workspaceId, userId, patch = {}, options = {}) {
@@ -117,8 +189,7 @@ function createRepository(knex) {
       throw new TypeError("workspaceMembershipsRepository.upsertMembership requires workspaceId and userId.");
     }
 
-    const client = options?.trx || knex;
-    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
+    const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
     const normalizedPatch = normalizeMembershipPatchPayload({
       roleSid: patch?.roleSid ?? existing?.roleSid ?? "member",
       status: patch?.status ?? existing?.status ?? "active"
@@ -128,42 +199,56 @@ function createRepository(knex) {
 
     if (!existing) {
       try {
-        await resourceRuntime.create(
+        await api.resources.workspaceMemberships.post(
           {
-            workspaceId: normalizedWorkspaceId,
-            userId: normalizedUserId,
-            roleSid,
-            status
+            inputRecord: createJsonApiInputRecord(
+              RESOURCE_TYPE,
+              {
+                roleSid,
+                status,
+                createdAt: new Date(),
+                updatedAt: new Date()
+              },
+              {
+                relationships: createMembershipRelationships({
+                  workspaceId: normalizedWorkspaceId,
+                  userId: normalizedUserId
+                })
+              }
+            ),
+            transaction: options?.trx || null,
+            simplified: false
           },
-          {
-            ...options,
-            trx: client,
-            include: "none"
-          }
+          createJsonRestContext(options?.context || null)
         );
       } catch (error) {
         if (!isDuplicateEntryError(error)) {
           throw error;
         }
       }
-      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
+      return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
     }
 
-    await resourceRuntime.updateById(
-      existing.id,
+    await api.resources.workspaceMemberships.patch(
       {
-        roleSid,
-        status
+        inputRecord: createJsonApiInputRecord(
+          RESOURCE_TYPE,
+          {
+            roleSid,
+            status,
+            updatedAt: new Date()
+          },
+          {
+            id: existing.id
+          }
+        ),
+        transaction: options?.trx || null,
+        simplified: false
       },
-      {
-        ...options,
-        trx: client,
-        include: "none",
-        existingRecord: existing
-      }
+      createJsonRestContext(options?.context || null)
     );
 
-    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
+    return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, options);
   }
 
   async function listActiveByWorkspaceId(workspaceId, options = {}) {
@@ -172,20 +257,27 @@ function createRepository(knex) {
       return [];
     }
 
-    const client = options?.trx || knex;
-    const rows = await client("workspace_memberships as wm")
-      .join("users as up", "up.id", "wm.user_id")
-      .where({ "wm.workspace_id": normalizedWorkspaceId, "wm.status": "active" })
-      .orderBy("up.display_name", "asc")
-      .select([
-        "wm.user_id",
-        "wm.role_sid",
-        "wm.status",
-        "up.display_name",
-        "up.email"
-      ]);
-
-    return rows.map(normalizeMemberSummaryRow).filter(Boolean);
+    const rows = await queryMemberships(
+      {
+        workspace: normalizedWorkspaceId,
+        status: "active"
+      },
+      options,
+      { includeUser: true }
+    );
+
+    const members = rows
+      .map((row) => normalizeMemberSummaryRow({
+        user_id: row?.user?.id,
+        role_sid: row?.roleSid,
+        status: row?.status,
+        display_name: row?.user?.displayName,
+        email: row?.user?.email
+      }))
+      .filter(Boolean);
+
+    members.sort((left, right) => String(left.displayName || "").localeCompare(String(right.displayName || "")));
+    return members;
   }
 
   async function listActiveWorkspaceIdsByUserId(userId, options = {}) {
@@ -194,17 +286,16 @@ function createRepository(knex) {
       return [];
     }
 
-    const client = options?.trx || knex;
-    const rows = await client("workspace_memberships")
-      .where({
-        user_id: normalizedUserId,
+    const rows = await queryMemberships(
+      {
+        user: normalizedUserId,
         status: "active"
-      })
-      .select("workspace_id")
-      .orderBy("workspace_id", "asc");
+      },
+      options
+    );
 
     return rows
-      .map((row) => normalizeDbRecordId(row.workspace_id, { fallback: null }))
+      .map((row) => normalizeDbRecordId(row?.workspace?.id || row?.workspaceId, { fallback: null }))
       .filter(Boolean);
   }