@jskit-ai/workspaces-core 0.1.21 → 0.1.23

package/package.descriptor.mjs

@@ -1,7 +1,7 @@
 export default Object.freeze({
   packageVersion: 1,
   packageId: "@jskit-ai/workspaces-core",
-  version: "0.1.21",
+  version: "0.1.23",
   kind: "runtime",
   description: "Workspace tenancy runtime plus HTTP routes, role catalog, and workspace config scaffolding.",
   dependsOn: [
@@ -112,7 +112,7 @@ export default Object.freeze({
   mutations: {
     dependencies: {
       runtime: {
-        "@jskit-ai/users-core": "0.1.55"
+        "@jskit-ai/users-core": "0.1.57"
       },
       dev: {}
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/workspaces-core",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "type": "module",
   "scripts": {
     "test": "node --test"
@@ -18,11 +18,11 @@
   },
   "dependencies": {
     "@fastify/type-provider-typebox": "^6.1.0",
-    "@jskit-ai/auth-core": "0.1.44",
-    "@jskit-ai/database-runtime": "0.1.45",
-    "@jskit-ai/http-runtime": "0.1.44",
-    "@jskit-ai/kernel": "0.1.45",
-    "@jskit-ai/users-core": "0.1.55",
+    "@jskit-ai/auth-core": "0.1.46",
+    "@jskit-ai/database-runtime": "0.1.47",
+    "@jskit-ai/http-runtime": "0.1.46",
+    "@jskit-ai/kernel": "0.1.47",
+    "@jskit-ai/users-core": "0.1.57",
     "typebox": "^1.0.81"
   }
 }

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

@@ -1,38 +1,39 @@
-import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
+import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
   normalizeLowerText,
-  normalizeDbRecordId,
   normalizeRecordId,
   normalizeText,
-  toIsoString,
-  toNullableIso,
-  toNullableDateTime,
   nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
+  isDuplicateEntryError
 } from "./repositoryUtils.js";
+import { workspaceInvitesResource } from "../resources/workspaceInvitesResource.js";
 
-function mapRow(row) {
-  if (!row) {
+const REPOSITORY_CONFIG = Object.freeze({
+  context: "internal.repository.workspace-invites"
+});
+
+function normalizeInviteRecord(payload = {}) {
+  if (!payload) {
+    return null;
+  }
+  return workspaceInvitesResource.operations.view.outputValidator.normalize(payload);
+}
+
+function normalizeInvitePatchPayload(payload = {}) {
+  return workspaceInvitesResource.operations.patch.bodyValidator.normalize(payload);
+}
+
+function normalizeInviteWithWorkspace(payload = {}) {
+  const invite = normalizeInviteRecord(payload);
+  if (!invite) {
     return null;
   }
 
   return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" }),
-    email: normalizeLowerText(row.email),
-    roleSid: normalizeLowerText(row.role_sid || "member") || "member",
-    status: normalizeLowerText(row.status || "pending") || "pending",
-    tokenHash: normalizeText(row.token_hash),
-    invitedByUserId: row.invited_by_user_id == null ? null : normalizeDbRecordId(row.invited_by_user_id, { fallback: null }),
-    expiresAt: toNullableIso(row.expires_at),
-    acceptedAt: toNullableIso(row.accepted_at),
-    revokedAt: toNullableIso(row.revoked_at),
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at),
-    workspaceSlug: row.workspace_slug ? normalizeText(row.workspace_slug) : undefined,
-    workspaceName: row.workspace_name ? normalizeText(row.workspace_name) : undefined,
-    workspaceAvatarUrl: row.workspace_avatar_url ? normalizeText(row.workspace_avatar_url) : undefined
+    ...invite,
+    workspaceSlug: payload?.workspace_slug ? normalizeText(payload.workspace_slug) : undefined,
+    workspaceName: payload?.workspace_name ? normalizeText(payload.workspace_name) : undefined,
+    workspaceAvatarUrl: payload?.workspace_avatar_url ? normalizeText(payload.workspace_avatar_url) : undefined
   };
 }
 
@@ -47,14 +48,15 @@ function createRepository(knex) {
   if (typeof knex !== "function") {
     throw new TypeError("workspaceInvitesRepository requires knex.");
   }
-  const withTransaction = createWithTransaction(knex);
+  const resourceRuntime = createCrudResourceRuntime(workspaceInvitesResource, knex, REPOSITORY_CONFIG);
+  const withTransaction = resourceRuntime.withTransaction;
 
   async function findPendingByTokenHash(tokenHash, options = {}) {
     const client = options?.trx || knex;
     const row = await client("workspace_invites")
       .where({ token_hash: normalizeText(tokenHash), status: "pending" })
       .first();
-    return mapRow(row);
+    return normalizeInviteRecord(row);
   }
 
   async function listPendingByEmail(email, options = {}) {
@@ -70,7 +72,7 @@ function createRepository(knex) {
       .orderBy("wi.created_at", "desc")
       .select(WORKSPACE_INVITE_WITH_WORKSPACE_SELECT);
 
-    return rows.map(mapRow).filter(Boolean);
+    return rows.map(normalizeInviteWithWorkspace).filter(Boolean);
   }
 
   async function listPendingByWorkspaceIdWithWorkspace(workspaceId, options = {}) {
@@ -86,38 +88,32 @@ function createRepository(knex) {
       .orderBy("wi.created_at", "desc")
       .select(WORKSPACE_INVITE_WITH_WORKSPACE_SELECT);
 
-    return rows.map(mapRow).filter(Boolean);
+    return rows.map(normalizeInviteWithWorkspace).filter(Boolean);
   }
 
   async function insert(payload = {}, options = {}) {
     const client = options?.trx || knex;
-    const source = payload && typeof payload === "object" ? payload : {};
+    const source = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
     const workspaceId = normalizeRecordId(source.workspaceId, { fallback: null });
     if (!workspaceId) {
       throw new TypeError("workspaceInvitesRepository.insert requires workspaceId.");
     }
 
-    const insertPayload = {
-      workspace_id: workspaceId,
-      email: normalizeLowerText(source.email),
-      role_sid: normalizeLowerText(source.roleSid || "member") || "member",
+    const createPayload = {
+      ...source,
+      workspaceId,
+      roleSid: normalizeLowerText(source.roleSid || "member") || "member",
       status: normalizeLowerText(source.status || "pending") || "pending",
-      token_hash: normalizeText(source.tokenHash),
-      invited_by_user_id: source.invitedByUserId == null ? null : normalizeRecordId(source.invitedByUserId, { fallback: null }),
-      expires_at: toNullableDateTime(source.expiresAt),
-      accepted_at: null,
-      revoked_at: null,
-      created_at: nowDb(),
-      updated_at: nowDb()
+      acceptedAt: null,
+      revokedAt: null
     };
 
     try {
-      const result = await client("workspace_invites").insert(insertPayload);
-      const insertedId = resolveInsertedRecordId(result, { fallback: null });
-      if (insertedId) {
-        const row = await client("workspace_invites").where({ id: insertedId }).first();
-        return mapRow(row);
-      }
+      return await resourceRuntime.create(createPayload, {
+        ...options,
+        trx: client,
+        include: "none"
+      });
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
@@ -125,10 +121,10 @@ function createRepository(knex) {
     }
 
     const row = await client("workspace_invites")
-      .where({ workspace_id: insertPayload.workspace_id, email: insertPayload.email, status: "pending" })
+      .where({ workspace_id: createPayload.workspaceId, email: createPayload.email, status: "pending" })
       .orderBy("id", "desc")
       .first();
-    return mapRow(row);
+    return normalizeInviteRecord(row);
   }
 
   async function expirePendingByWorkspaceIdAndEmail(workspaceId, email, options = {}) {
@@ -138,10 +134,11 @@ function createRepository(knex) {
     }
 
     const client = options?.trx || knex;
+    const patch = normalizeInvitePatchPayload({ status: "expired" });
     await client("workspace_invites")
       .where({ workspace_id: normalizedWorkspaceId, email: normalizeLowerText(email), status: "pending" })
       .update({
-        status: "expired",
+        status: patch.status,
         updated_at: nowDb()
       });
   }
@@ -152,14 +149,17 @@ function createRepository(knex) {
       return;
     }
 
-    const client = options?.trx || knex;
-    await client("workspace_invites")
-      .where({ id: normalizedInviteId })
-      .update({
+    await resourceRuntime.updateById(
+      normalizedInviteId,
+      {
         status: "accepted",
-        accepted_at: nowDb(),
-        updated_at: nowDb()
-      });
+        acceptedAt: new Date()
+      },
+      {
+        ...options,
+        include: "none"
+      }
+    );
   }
 
   async function revokeById(inviteId, options = {}) {
@@ -168,14 +168,17 @@ function createRepository(knex) {
       return;
     }
 
-    const client = options?.trx || knex;
-    await client("workspace_invites")
-      .where({ id: normalizedInviteId })
-      .update({
+    await resourceRuntime.updateById(
+      normalizedInviteId,
+      {
         status: "revoked",
-        revoked_at: nowDb(),
-        updated_at: nowDb()
-      });
+        revokedAt: new Date()
+      },
+      {
+        ...options,
+        include: "none"
+      }
+    );
   }
 
   async function findPendingByIdForWorkspace(inviteId, workspaceId, options = {}) {
@@ -189,7 +192,7 @@ function createRepository(knex) {
     const row = await client("workspace_invites")
       .where({ id: normalizedInviteId, workspace_id: normalizedWorkspaceId, status: "pending" })
       .first();
-    return mapRow(row);
+    return normalizeInviteRecord(row);
   }
 
   return Object.freeze({
@@ -205,4 +208,4 @@ function createRepository(knex) {
   });
 }
 
-export { createRepository, mapRow };
+export { createRepository, normalizeInviteRecord, normalizeInviteWithWorkspace };

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

@@ -1,32 +1,30 @@
+import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
   normalizeLowerText,
   normalizeRecordId,
   normalizeDbRecordId,
   normalizeText,
-  toIsoString,
-  nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
+  isDuplicateEntryError
 } from "./repositoryUtils.js";
 import { OWNER_ROLE_ID } from "../../../shared/roles.js";
+import { workspaceMembershipsResource } from "../resources/workspaceMembershipsResource.js";
 
-function mapRow(row) {
-  if (!row) {
+const REPOSITORY_CONFIG = Object.freeze({
+  context: "internal.repository.workspace-memberships"
+});
+
+function normalizeMembershipRecord(payload = {}) {
+  if (!payload) {
     return null;
   }
+  return workspaceMembershipsResource.operations.view.outputValidator.normalize(payload);
+}
 
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    workspaceId: normalizeDbRecordId(row.workspace_id, { fallback: "" }),
-    userId: normalizeDbRecordId(row.user_id, { fallback: "" }),
-    roleSid: normalizeLowerText(row.role_sid || "member") || "member",
-    status: normalizeLowerText(row.status || "active") || "active",
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at)
-  };
+function normalizeMembershipPatchPayload(payload = {}) {
+  return workspaceMembershipsResource.operations.patch.bodyValidator.normalize(payload);
 }
 
-function mapMemberSummaryRow(row) {
+function normalizeMemberSummaryRow(row) {
   if (!row) {
     return null;
   }
@@ -44,7 +42,8 @@ function createRepository(knex) {
   if (typeof knex !== "function") {
     throw new TypeError("workspaceMembershipsRepository requires knex.");
   }
-  const withTransaction = createWithTransaction(knex);
+  const resourceRuntime = createCrudResourceRuntime(workspaceMembershipsResource, knex, REPOSITORY_CONFIG);
+  const withTransaction = resourceRuntime.withTransaction;
 
   async function findByWorkspaceIdAndUserId(workspaceId, userId, options = {}) {
     const normalizedWorkspaceId = normalizeRecordId(workspaceId, { fallback: null });
@@ -57,7 +56,7 @@ function createRepository(knex) {
     const row = await client("workspace_memberships")
       .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
       .first();
-    return mapRow(row);
+    return normalizeMembershipRecord(row);
   }
 
   async function ensureOwnerMembership(workspaceId, userId, options = {}) {
@@ -71,26 +70,37 @@ function createRepository(knex) {
     const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     if (existing) {
       if (existing.roleSid !== OWNER_ROLE_ID || existing.status !== "active") {
-        await client("workspace_memberships")
-          .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
-          .update({
-            role_sid: OWNER_ROLE_ID,
-            status: "active",
-            updated_at: nowDb()
-          });
+        await resourceRuntime.updateById(
+          existing.id,
+          {
+            roleSid: OWNER_ROLE_ID,
+            status: "active"
+          },
+          {
+            ...options,
+            trx: client,
+            include: "none",
+            existingRecord: existing
+          }
+        );
       }
       return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     }
 
     try {
-      await client("workspace_memberships").insert({
-        workspace_id: normalizedWorkspaceId,
-        user_id: normalizedUserId,
-        role_sid: OWNER_ROLE_ID,
-        status: "active",
-        created_at: nowDb(),
-        updated_at: nowDb()
-      });
+      await resourceRuntime.create(
+        {
+          workspaceId: normalizedWorkspaceId,
+          userId: normalizedUserId,
+          roleSid: OWNER_ROLE_ID,
+          status: "active"
+        },
+        {
+          ...options,
+          trx: client,
+          include: "none"
+        }
+      );
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
@@ -109,28 +119,49 @@ function createRepository(knex) {
 
     const client = options?.trx || knex;
     const existing = await findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
-    const roleSid = normalizeLowerText(patch.roleSid || existing?.roleSid || "member") || "member";
-    const status = normalizeLowerText(patch.status || existing?.status || "active") || "active";
+    const normalizedPatch = normalizeMembershipPatchPayload({
+      roleSid: patch?.roleSid ?? existing?.roleSid ?? "member",
+      status: patch?.status ?? existing?.status ?? "active"
+    });
+    const roleSid = normalizeLowerText(normalizedPatch.roleSid || "member") || "member";
+    const status = normalizeLowerText(normalizedPatch.status || "active") || "active";
 
     if (!existing) {
-      await client("workspace_memberships").insert({
-        workspace_id: normalizedWorkspaceId,
-        user_id: normalizedUserId,
-        role_sid: roleSid,
-        status,
-        created_at: nowDb(),
-        updated_at: nowDb()
-      });
+      try {
+        await resourceRuntime.create(
+          {
+            workspaceId: normalizedWorkspaceId,
+            userId: normalizedUserId,
+            roleSid,
+            status
+          },
+          {
+            ...options,
+            trx: client,
+            include: "none"
+          }
+        );
+      } catch (error) {
+        if (!isDuplicateEntryError(error)) {
+          throw error;
+        }
+      }
       return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
     }
 
-    await client("workspace_memberships")
-      .where({ workspace_id: normalizedWorkspaceId, user_id: normalizedUserId })
-      .update({
-        role_sid: roleSid,
-        status,
-        updated_at: nowDb()
-      });
+    await resourceRuntime.updateById(
+      existing.id,
+      {
+        roleSid,
+        status
+      },
+      {
+        ...options,
+        trx: client,
+        include: "none",
+        existingRecord: existing
+      }
+    );
 
     return findByWorkspaceIdAndUserId(normalizedWorkspaceId, normalizedUserId, { trx: client });
   }
@@ -154,7 +185,7 @@ function createRepository(knex) {
         "up.email"
       ]);
 
-    return rows.map(mapMemberSummaryRow).filter(Boolean);
+    return rows.map(normalizeMemberSummaryRow).filter(Boolean);
   }
 
   async function listActiveWorkspaceIdsByUserId(userId, options = {}) {
@@ -187,4 +218,4 @@ function createRepository(knex) {
   });
 }
 
-export { createRepository, mapRow, mapMemberSummaryRow };
+export { createRepository, normalizeMembershipRecord, normalizeMemberSummaryRow };

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

@@ -1,41 +1,34 @@
-import { resolveInsertedRecordId } from "@jskit-ai/database-runtime/shared";
+import { createCrudResourceRuntime } from "@jskit-ai/crud-core/server/resourceRuntime";
 import {
-  normalizeDbRecordId,
   normalizeRecordId,
   normalizeText,
   normalizeLowerText,
-  toIsoString,
-  toNullableIso,
-  nowDb,
-  isDuplicateEntryError,
-  createWithTransaction
+  isDuplicateEntryError
 } from "./repositoryUtils.js";
+import { workspacesResource } from "../resources/workspacesResource.js";
 
-function mapRow(row) {
-  if (!row) {
+const REPOSITORY_CONFIG = Object.freeze({
+  context: "internal.repository.workspaces"
+});
+
+function normalizeWorkspaceRecord(payload = {}) {
+  if (!payload) {
     return null;
   }
+  return workspacesResource.operations.view.outputValidator.normalize(payload);
+}
 
-  return {
-    id: normalizeDbRecordId(row.id, { fallback: "" }),
-    slug: normalizeText(row.slug),
-    name: normalizeText(row.name),
-    ownerUserId: normalizeDbRecordId(row.owner_user_id, { fallback: "" }),
-    isPersonal: Boolean(row.is_personal),
-    avatarUrl: row.avatar_url ? normalizeText(row.avatar_url) : "",
-    createdAt: toIsoString(row.created_at),
-    updatedAt: toIsoString(row.updated_at),
-    deletedAt: toNullableIso(row.deleted_at)
-  };
+function normalizeCreatePayload(payload = {}) {
+  return workspacesResource.operations.create.bodyValidator.normalize(payload);
 }
 
-function mapMembershipWorkspaceRow(row) {
+function normalizeMembershipWorkspaceRow(row) {
   if (!row) {
     return null;
   }
 
   return {
-    ...mapRow(row),
+    ...normalizeWorkspaceRecord(row),
     roleSid: normalizeLowerText(row.role_sid || "member"),
     membershipStatus: normalizeLowerText(row.membership_status || "active") || "active"
   };
@@ -45,7 +38,8 @@ function createRepository(knex) {
   if (typeof knex !== "function") {
     throw new TypeError("workspacesRepository requires knex.");
   }
-  const withTransaction = createWithTransaction(knex);
+  const resourceRuntime = createCrudResourceRuntime(workspacesResource, knex, REPOSITORY_CONFIG);
+  const withTransaction = resourceRuntime.withTransaction;
 
   function workspaceSelectColumns({ includeMembership = false } = {}) {
     const columns = [
@@ -71,12 +65,10 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    const row = await client("workspaces as w")
-      .where({ "w.id": normalizedWorkspaceId })
-      .select(workspaceSelectColumns())
-      .first();
-    return mapRow(row);
+    return resourceRuntime.findById(normalizedWorkspaceId, {
+      ...options,
+      include: "none"
+    });
   }
 
   async function findBySlug(slug, options = {}) {
@@ -90,7 +82,7 @@ function createRepository(knex) {
       .where({ "w.slug": normalizedSlug })
       .select(workspaceSelectColumns())
       .first();
-    return mapRow(row);
+    return normalizeWorkspaceRecord(row);
   }
 
   async function findPersonalByOwnerUserId(userId, options = {}) {
@@ -105,41 +97,35 @@ function createRepository(knex) {
       .orderBy("w.id", "asc")
       .select(workspaceSelectColumns())
       .first();
-    return mapRow(row);
+    return normalizeWorkspaceRecord(row);
   }
 
   async function insert(payload = {}, options = {}) {
     const client = options?.trx || knex;
-    const source = payload && typeof payload === "object" ? payload : {};
-    const ownerUserId = normalizeRecordId(source.ownerUserId, { fallback: null });
+    const normalizedPayload = normalizeCreatePayload(payload);
+    const ownerUserId = normalizeRecordId(normalizedPayload.ownerUserId, { fallback: null });
     if (!ownerUserId) {
       throw new TypeError("workspacesRepository.insert requires ownerUserId.");
     }
 
-    const insertPayload = {
-      slug: normalizeLowerText(source.slug),
-      name: normalizeText(source.name),
-      owner_user_id: ownerUserId,
-      is_personal: source.isPersonal ? 1 : 0,
-      avatar_url: normalizeText(source.avatarUrl),
-      created_at: nowDb(),
-      updated_at: nowDb(),
-      deleted_at: null
+    const createPayload = {
+      ...normalizedPayload,
+      ownerUserId,
+      isPersonal: normalizedPayload.isPersonal === true,
+      avatarUrl: normalizeText(normalizedPayload.avatarUrl)
     };
 
     try {
-      const result = await client("workspaces").insert(insertPayload);
-      const insertedId = resolveInsertedRecordId(result, { fallback: null });
-      if (insertedId) {
-        return findById(insertedId, { trx: client });
-      }
-      const bySlug = await findBySlug(insertPayload.slug, { trx: client });
-      return bySlug;
+      return await resourceRuntime.create(createPayload, {
+        ...options,
+        trx: client,
+        include: "none"
+      });
     } catch (error) {
       if (!isDuplicateEntryError(error)) {
         throw error;
       }
-      const bySlug = await findBySlug(insertPayload.slug, { trx: client });
+      const bySlug = await findBySlug(createPayload.slug, { trx: client });
       if (bySlug) {
         return bySlug;
       }
@@ -153,21 +139,10 @@ function createRepository(knex) {
       return null;
     }
 
-    const client = options?.trx || knex;
-    const source = patch && typeof patch === "object" ? patch : {};
-    const dbPatch = {
-      updated_at: nowDb()
-    };
-
-    if (Object.hasOwn(source, "name")) {
-      dbPatch.name = normalizeText(source.name);
-    }
-    if (Object.hasOwn(source, "avatarUrl")) {
-      dbPatch.avatar_url = normalizeText(source.avatarUrl);
-    }
-
-    await client("workspaces").where({ id: normalizedWorkspaceId }).update(dbPatch);
-    return findById(normalizedWorkspaceId, { trx: client });
+    return resourceRuntime.updateById(normalizedWorkspaceId, patch, {
+      ...options,
+      include: "none"
+    });
   }
 
   async function listForUserId(userId, options = {}) {
@@ -185,7 +160,7 @@ function createRepository(knex) {
       .orderBy("w.id", "asc")
       .select(workspaceSelectColumns({ includeMembership: true }));
 
-    return rows.map(mapMembershipWorkspaceRow).filter(Boolean);
+    return rows.map(normalizeMembershipWorkspaceRow).filter(Boolean);
   }
 
   return Object.freeze({
@@ -199,4 +174,4 @@ function createRepository(knex) {
   });
 }
 
-export { createRepository, mapRow, mapMembershipWorkspaceRow };
+export { createRepository, normalizeWorkspaceRecord, normalizeMembershipWorkspaceRow };