@arcote.tech/arc-workspace 0.4.10 → 0.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-workspace",
   "type": "module",
-  "version": "0.4.10",
+  "version": "0.5.0",
   "private": false,
   "description": "Reusable workspace module for Arc framework — multi-workspace with dual token architecture",
   "main": "./src/index.ts",
@@ -10,8 +10,8 @@
     "type-check": "tsc --noEmit"
   },
   "peerDependencies": {
-    "@arcote.tech/arc": "^0.4.10",
-    "@arcote.tech/arc-auth": "^0.4.10",
+    "@arcote.tech/arc": "^0.5.0",
+    "@arcote.tech/arc-auth": "^0.5.0",
     "typescript": "^5.0.0"
   },
   "devDependencies": {

package/src/aggregates/workspace-invitation.ts

@@ -1,9 +1,4 @@
-import {
-  aggregate,
-  date,
-  string,
-  type ArcId,
-} from "@arcote.tech/arc";
+import { aggregate, date, string, type ArcId } from "@arcote.tech/arc";
 import type { Token } from "@arcote.tech/arc-auth";
 import type { WorkspaceToken } from "../tokens/workspace-token";
 
@@ -17,7 +12,8 @@ export type WorkspaceInvitationAggregateData = {
 };
 
 function generateInviteToken(): string {
-  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
   let result = "";
   for (let i = 0; i < 32; i++) {
     result += chars.charAt(Math.floor(Math.random() * chars.length));
@@ -39,7 +35,7 @@ export const createWorkspaceInvitationAggregate = <
   } = data;
 
   return aggregate(
-    `${data.name}WorkspaceInvitations`,
+    `${data.name as Data["name"]}WorkspaceInvitations`,
     workspaceInvitationId,
     {
       workspaceId,
@@ -113,107 +109,115 @@ export const createWorkspaceInvitationAggregate = <
 
     .mutateMethod(
       "createInvitation",
-      {
-        params: {
-          workspaceId,
-          role: string(),
-          workspaceName: string(),
-          workspaceType: string(),
-          email: string().optional(),
-        },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const invId = workspaceInvitationId.generate();
-          const token = generateInviteToken();
-          const expiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000); // 7 days
-
-          await ctx.invitationCreated.emit({
-            workspaceInvitationId: invId,
-            workspaceId: params.workspaceId,
-            invitedBy: ctx.$auth.params.accountId,
-            role: params.role,
-            token,
-            email: params.email,
-            workspaceName: params.workspaceName,
-            workspaceType: params.workspaceType,
-            expiresAt,
-          });
-
-          return { workspaceInvitationId: invId, token };
-        }),
+      (fn) =>
+        fn
+          .withParams({
+            workspaceId,
+            role: string(),
+            workspaceName: string(),
+            workspaceType: string(),
+            email: string().optional(),
+          })
+          .handle(
+            ONLY_SERVER &&
+              (async (ctx, params) => {
+                const invId = workspaceInvitationId.generate();
+                const token = generateInviteToken();
+                const expiresAt = new Date(
+                  Date.now() + 7 * 24 * 60 * 60 * 1000,
+                ); // 7 days
+
+                await ctx.invitationCreated.emit({
+                  workspaceInvitationId: invId,
+                  workspaceId: params.workspaceId,
+                  invitedBy: ctx.$auth.params.accountId,
+                  role: params.role,
+                  token,
+                  email: params.email,
+                  workspaceName: params.workspaceName,
+                  workspaceType: params.workspaceType,
+                  expiresAt,
+                });
+
+                return { workspaceInvitationId: invId, token };
+              }),
+          ),
     )
 
     .mutateMethod(
       "acceptInvitation",
-      { params: { token: string() } },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const invitation = await ctx.$query.findOne({
-            token: params.token,
-          });
-
-          if (!invitation) {
-            return { error: "INVITATION_NOT_FOUND" as const };
-          }
-          if (invitation.status !== "pending") {
-            return { error: "INVITATION_NOT_VALID" as const };
-          }
-          if (new Date(invitation.expiresAt) < new Date()) {
-            return { error: "INVITATION_EXPIRED" as const };
-          }
-
-          // Emit accepted event — WorkspaceMember handles adding the member
-          await ctx.invitationAccepted.emit({
-            workspaceInvitationId: invitation._id,
-            workspaceId: invitation.workspaceId,
-            acceptedBy: ctx.$auth.params.accountId,
-            role: invitation.role,
-            workspaceName: invitation.workspaceName,
-            workspaceType: invitation.workspaceType,
-          });
-
-          // Generate workspace token for the new member
-          const wsToken = workspaceToken.generateJWT({
-            accountId: ctx.$auth.params.accountId,
-            workspaceId: invitation.workspaceId,
-            role: invitation.role,
-            workspaceType: invitation.workspaceType,
-          });
-
-          return {
-            success: true,
-            token: wsToken,
-            workspaceId: invitation.workspaceId,
-          };
-        }),
+      (fn) =>
+        fn.withParams({ token: string() }).handle(
+          ONLY_SERVER &&
+            (async (ctx, params) => {
+              const invitation = await ctx.$query.findOne({
+                token: params.token,
+              });
+
+              if (!invitation) {
+                return { error: "INVITATION_NOT_FOUND" as const };
+              }
+              if (invitation.status !== "pending") {
+                return { error: "INVITATION_NOT_VALID" as const };
+              }
+              if (new Date(invitation.expiresAt) < new Date()) {
+                return { error: "INVITATION_EXPIRED" as const };
+              }
+
+              // Emit accepted event — WorkspaceMember handles adding the member
+              await ctx.invitationAccepted.emit({
+                workspaceInvitationId: invitation._id,
+                workspaceId: invitation.workspaceId,
+                acceptedBy: ctx.$auth.params.accountId,
+                role: invitation.role,
+                workspaceName: invitation.workspaceName,
+                workspaceType: invitation.workspaceType,
+              });
+
+              // Generate workspace token for the new member
+              const wsToken = workspaceToken.generateJWT({
+                accountId: ctx.$auth.params.accountId,
+                workspaceId: invitation.workspaceId,
+                role: invitation.role,
+                workspaceType: invitation.workspaceType,
+              });
+
+              return {
+                success: true,
+                token: wsToken,
+                workspaceId: invitation.workspaceId,
+              };
+            }),
+        ),
     )
 
     .mutateMethod(
       "revokeInvitation",
-      { params: { workspaceInvitationId } },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const invitation = await ctx.$query.findOne({
-            _id: params.workspaceInvitationId,
-          });
-          if (!invitation || invitation.status !== "pending") {
-            return { error: "INVITATION_NOT_VALID" as const };
-          }
-
-          await ctx.invitationRevoked.emit({
-            workspaceInvitationId: params.workspaceInvitationId,
-          });
-
-          return { success: true };
-        }),
+      (fn) =>
+        fn.withParams({ workspaceInvitationId }).handle(
+          ONLY_SERVER &&
+            (async (ctx, params) => {
+              const invitation = await ctx.$query.findOne({
+                _id: params.workspaceInvitationId,
+              });
+              if (!invitation || invitation.status !== "pending") {
+                return { error: "INVITATION_NOT_VALID" as const };
+              }
+
+              await ctx.invitationRevoked.emit({
+                workspaceInvitationId: params.workspaceInvitationId,
+              });
+
+              return { success: true };
+            }),
+        ),
     )
 
-    .protectBy(userToken, (p: any) => ({ invitedBy: p.accountId }))
-    .clientQuery("getByWorkspace", async (ctx) => ctx.$query.find({}))
-  ;
+    .protectBy(userToken, (p) => ({ invitedBy: p.accountId }))
+    .clientQuery("getByWorkspace", (fn) => fn.handle(async (ctx) => ctx.$query.find({})));
 };
 
 export type WorkspaceInvitationAggregate<
-  Data extends WorkspaceInvitationAggregateData = WorkspaceInvitationAggregateData,
+  Data extends WorkspaceInvitationAggregateData =
+    WorkspaceInvitationAggregateData,
 > = ReturnType<typeof createWorkspaceInvitationAggregate<Data>>;

package/src/aggregates/workspace-member.ts

@@ -1,12 +1,8 @@
-import {
-  aggregate,
-  date,
-  string,
-  type ArcAggregateElement,
-  type ArcId,
-} from "@arcote.tech/arc";
+import { aggregate, date, string, type ArcId } from "@arcote.tech/arc";
 import type { Token } from "@arcote.tech/arc-auth";
 import type { WorkspaceToken } from "../tokens/workspace-token";
+import type { createWorkspaceAggregate } from "./workspace";
+import type { createWorkspaceInvitationAggregate } from "./workspace-invitation";
 
 export type WorkspaceMemberAggregateData = {
   name: string;
@@ -15,8 +11,10 @@ export type WorkspaceMemberAggregateData = {
   accountId: ArcId<any>;
   workspaceToken: WorkspaceToken;
   userToken: Token;
-  WorkspaceAggregate: ArcAggregateElement<any, any, any, any, any, any>;
-  WorkspaceInvitationAggregate?: ArcAggregateElement<any, any, any, any, any, any>;
+  WorkspaceAggregate: ReturnType<typeof createWorkspaceAggregate>;
+  WorkspaceInvitationAggregate: ReturnType<
+    typeof createWorkspaceInvitationAggregate
+  >;
 };
 
 export const createWorkspaceMemberAggregate = <
@@ -34,226 +32,238 @@ export const createWorkspaceMemberAggregate = <
     WorkspaceInvitationAggregate,
   } = data;
 
-  const workspaceCreatedEvent = WorkspaceAggregate.getEvent("workspaceCreated");
+  const name = data.name as Data["name"];
 
-  let Constructor = aggregate(
-    `${data.name}WorkspaceMembers`,
-    workspaceMemberId,
-    {
+  return (
+    aggregate(`${name}WorkspaceMembers`, workspaceMemberId, {
       workspaceId,
       accountId,
       role: string(),
       workspaceName: string(),
       workspaceType: string(),
       joinedAt: date(),
-    },
-  )
-    .publicEvent(
-      "workspaceMemberAdded",
-      {
-        workspaceMemberId,
-        workspaceId,
-        accountId,
-        role: string(),
-        workspaceName: string(),
-        workspaceType: string(),
-      },
-      async (ctx, event) => {
-        const {
-          workspaceMemberId: id,
-          workspaceId: wsId,
-          accountId: accId,
-          role,
-          workspaceName,
-          workspaceType,
-        } = event.payload;
-        await ctx.set(id, {
-          workspaceId: wsId,
-          accountId: accId,
-          role,
-          workspaceName,
-          workspaceType,
-          joinedAt: event.createdAt,
-        });
-      },
-    )
-
-    .publicEvent(
-      "workspaceMemberRemoved",
-      { workspaceMemberId },
-      async (ctx, event) => {
-        await ctx.remove(event.payload.workspaceMemberId);
-      },
-    )
-
-    .publicEvent(
-      "workspaceMemberRoleChanged",
-      {
-        workspaceMemberId,
-        role: string(),
-      },
-      async (ctx, event) => {
-        await ctx.modify(event.payload.workspaceMemberId, {
-          role: event.payload.role,
-        });
-      },
-    )
-
-    // Auto-create owner membership when workspace is created
-    .handleEvent(workspaceCreatedEvent, async (ctx, event) => {
-      await ctx.set(event.payload.ownerMemberId, {
-        workspaceId: event.payload.workspaceId,
-        accountId: event.payload.ownerId,
-        role: "owner",
-        workspaceName: event.payload.name,
-        workspaceType: event.payload.type,
-        joinedAt: event.createdAt,
-      });
     })
-
-    // Remove all members when workspace is archived
-    .handleEvent(WorkspaceAggregate.getEvent("workspaceArchived"), async (ctx, event) => {
-      const members = await ctx.find({
-        where: { workspaceId: event.payload.workspaceId },
-      });
-      for (const member of members) {
-        await ctx.remove(member._id);
-      }
-    })
-
-    // Sync workspace name to all members when workspace is renamed
-    .handleEvent(WorkspaceAggregate.getEvent("workspaceRenamed"), async (ctx, event) => {
-      const members = await ctx.find({
-        where: { workspaceId: event.payload.workspaceId },
-      });
-      for (const member of members) {
-        await ctx.modify(member._id, {
-          workspaceName: event.payload.name,
-        });
-      }
-    })
-
-  ;
-
-  // Auto-add member when invitation is accepted
-  if (WorkspaceInvitationAggregate) {
-    const invitationAcceptedEvent = WorkspaceInvitationAggregate.getEvent("invitationAccepted");
-    Constructor = Constructor.handleEvent(invitationAcceptedEvent, async (ctx, event) => {
-      const p = event.payload;
-      const memberId = workspaceMemberId.generate();
-      await ctx.set(memberId, {
-        workspaceId: p.workspaceId,
-        accountId: p.acceptedBy,
-        role: p.role,
-        workspaceName: p.workspaceName,
-        workspaceType: p.workspaceType,
-        joinedAt: event.createdAt,
-      });
-    });
-  }
-
-  Constructor = Constructor.mutateMethod(
-      "addMember",
-      {
-        params: {
+      .publicEvent(
+        "memberAdded",
+        {
+          workspaceMemberId,
           workspaceId,
           accountId,
           role: string(),
           workspaceName: string(),
           workspaceType: string(),
         },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const existing = await ctx.$query.findOne({
-            workspaceId: params.workspaceId,
-            accountId: params.accountId,
-          });
-          if (existing) {
-            return { error: "ALREADY_A_MEMBER" as const };
-          }
-
-          const id = workspaceMemberId.generate();
-
-          await ctx.workspaceMemberAdded.emit({
+        async (ctx, event) => {
+          const {
             workspaceMemberId: id,
-            workspaceId: params.workspaceId,
-            accountId: params.accountId,
-            role: params.role,
-            workspaceName: params.workspaceName,
-            workspaceType: params.workspaceType,
+            workspaceId: wsId,
+            accountId: accId,
+            role,
+            workspaceName,
+            workspaceType,
+          } = event.payload;
+          await ctx.set(id, {
+            workspaceId: wsId,
+            accountId: accId,
+            role,
+            workspaceName,
+            workspaceType,
+            joinedAt: event.createdAt,
           });
+        },
+      )
 
-          return { workspaceMemberId: id };
-        }),
-    )
-
-    .mutateMethod(
-      "removeMember",
-      { params: { workspaceMemberId } },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          await ctx.workspaceMemberRemoved.emit({
-            workspaceMemberId: params.workspaceMemberId,
-          });
-        }),
-    )
+      .publicEvent(
+        "memberRemoved",
+        { workspaceMemberId },
+        async (ctx, event) => {
+          await ctx.remove(event.payload.workspaceMemberId);
+        },
+      )
 
-    .mutateMethod(
-      "changeRole",
-      {
-        params: {
+      .publicEvent(
+        "roleChanged",
+        {
           workspaceMemberId,
           role: string(),
         },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          await ctx.workspaceMemberRoleChanged.emit({
-            workspaceMemberId: params.workspaceMemberId,
-            role: params.role,
+        async (ctx, event) => {
+          await ctx.modify(event.payload.workspaceMemberId, {
+            role: event.payload.role,
           });
-        }),
-    )
+        },
+      )
 
-    .mutateMethod(
-      "switchWorkspace",
-      { params: { workspaceMemberId } },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const member = await ctx.$query.findOne({
-            _id: params.workspaceMemberId,
+      // Auto-create owner membership when workspace is created
+      .handleEvent(
+        WorkspaceAggregate.getEvent("workspaceCreated"),
+        async (ctx, event) => {
+          await ctx.set(event.payload.ownerMemberId, {
+            workspaceId: event.payload.workspaceId,
+            accountId: event.payload.ownerId,
+            role: "owner",
+            workspaceName: event.payload.name,
+            workspaceType: event.payload.type,
+            joinedAt: event.createdAt,
           });
+        },
+      )
 
-          if (!member) {
-            return { error: "NOT_A_MEMBER" as const };
+      // Remove all members when workspace is archived
+      .handleEvent(
+        WorkspaceAggregate.getEvent("workspaceArchived"),
+        async (ctx, event) => {
+          const members = await ctx.find({
+            where: { workspaceId: event.payload.workspaceId },
+          });
+          for (const member of members) {
+            await ctx.remove(member._id);
           }
+        },
+      )
 
-          if (
-            ctx.$auth.params.accountId &&
-            ctx.$auth.params.accountId !== member.accountId
-          ) {
-            return { error: "NOT_A_MEMBER" as const };
+      // Sync workspace name to all members when workspace is renamed
+      .handleEvent(
+        WorkspaceAggregate.getEvent("workspaceRenamed"),
+        async (ctx, event) => {
+          const members = await ctx.find({
+            where: { workspaceId: event.payload.workspaceId },
+          });
+          for (const member of members) {
+            await ctx.modify(member._id, {
+              workspaceName: event.payload.name,
+            });
           }
+        },
+      )
 
-          const token = workspaceToken.generateJWT({
-            accountId: member.accountId,
-            workspaceId: member.workspaceId,
-            role: member.role,
-            workspaceType: member.workspaceType,
+      // Auto-add member when invitation is accepted
+      .handleEvent(
+        WorkspaceInvitationAggregate.getEvent("invitationAccepted"),
+        async (ctx, event) => {
+          const p = event.payload;
+          const memberId = workspaceMemberId.generate();
+          await ctx.set(memberId, {
+            workspaceId: p.workspaceId,
+            accountId: p.acceptedBy,
+            role: p.role,
+            workspaceName: p.workspaceName,
+            workspaceType: p.workspaceType,
+            joinedAt: event.createdAt,
           });
+        },
+      )
+
+      .mutateMethod(
+        "addMember",
+        (fn) =>
+          fn
+            .withParams({
+              workspaceId,
+              accountId,
+              role: string(),
+              workspaceName: string(),
+              workspaceType: string(),
+            })
+            .handle(
+              ONLY_SERVER &&
+                (async (ctx, params) => {
+                  const existing = await ctx.$query.findOne({
+                    workspaceId: params.workspaceId,
+                    accountId: params.accountId,
+                  });
+                  if (existing) {
+                    return { error: "ALREADY_A_MEMBER" as const };
+                  }
+
+                  const id = workspaceMemberId.generate();
+
+                  await ctx.memberAdded.emit({
+                    workspaceMemberId: id,
+                    workspaceId: params.workspaceId,
+                    accountId: params.accountId,
+                    role: params.role,
+                    workspaceName: params.workspaceName,
+                    workspaceType: params.workspaceType,
+                  });
+
+                  return { workspaceMemberId: id };
+                }),
+            ),
+      )
+
+      .mutateMethod(
+        "removeMember",
+        (fn) =>
+          fn.withParams({ workspaceMemberId }).handle(
+            ONLY_SERVER &&
+              (async (ctx, params) => {
+                await ctx.memberRemoved.emit({
+                  workspaceMemberId: params.workspaceMemberId,
+                });
+              }),
+          ),
+      )
+
+      .mutateMethod(
+        "changeRole",
+        (fn) =>
+          fn
+            .withParams({
+              workspaceMemberId,
+              role: string(),
+            })
+            .handle(
+              ONLY_SERVER &&
+                (async (ctx, params) => {
+                  await ctx.roleChanged.emit({
+                    workspaceMemberId: params.workspaceMemberId,
+                    role: params.role,
+                  });
+                }),
+            ),
+      )
+
+      .mutateMethod(
+        "switchWorkspace",
+        (fn) =>
+          fn.withParams({ workspaceMemberId }).handle(
+            ONLY_SERVER &&
+              (async (ctx, params) => {
+                const member = await ctx.$query.findOne({
+                  _id: params.workspaceMemberId,
+                });
+
+                if (!member) {
+                  return { error: "NOT_A_MEMBER" as const };
+                }
+
+                if (
+                  ctx.$auth.params.accountId &&
+                  ctx.$auth.params.accountId !== member.accountId
+                ) {
+                  return { error: "NOT_A_MEMBER" as const };
+                }
 
-          return { token };
-        }),
-    )
+                const token = workspaceToken.generateJWT({
+                  accountId: member.accountId,
+                  workspaceId: member.workspaceId,
+                  role: member.role,
+                  workspaceType: member.workspaceType,
+                });
 
-    .protectBy(userToken, (params: any) => ({ accountId: params.accountId }))
-    .protectBy(workspaceToken, (params: any) => ({ workspaceId: params.workspaceId }))
-    .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
-    .clientQuery("getByWorkspace", async (ctx) => ctx.$query.find({}))
-;
+                return { token };
+              }),
+          ),
+      )
 
-  return Constructor;
+      .protectBy(userToken, (params) => ({ accountId: params.accountId }))
+      .protectBy(workspaceToken, (params) => ({
+        workspaceId: params.workspaceId,
+      }))
+      .clientQuery("getAll", (fn) => fn.handle(async (ctx) => ctx.$query.find({})))
+      .clientQuery("getByWorkspace", (fn) => fn.handle(async (ctx) => ctx.$query.find({})))
+  );
 };
 
 export type WorkspaceMemberAggregate<

package/src/aggregates/workspace.ts

@@ -16,7 +16,7 @@ export const createWorkspaceAggregate = <
 ) => {
   const { workspaceId, workspaceMemberId, accountId, workspaceToken } = data;
 
-  return aggregate(`${data.name}Workspaces`, workspaceId, {
+  return aggregate(`${data.name as Data["name"]}Workspaces`, workspaceId, {
     name: string().minLength(1).maxLength(100),
     type: string(),
     ownerId: accountId,
@@ -59,95 +59,96 @@ export const createWorkspaceAggregate = <
 
     .mutateMethod(
       "create",
-      {
-        params: {
-          name: string().minLength(1).maxLength(100),
-          type: string(),
-        },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const id = workspaceId.generate();
-          const ownerMemberId = workspaceMemberId.generate();
-          const ownerId = ctx.$auth.params.accountId;
-
-          await ctx.workspaceCreated.emit({
-            workspaceId: id,
-            ownerMemberId,
-            name: params.name,
-            type: params.type,
-            ownerId,
-          });
-
-          const token = workspaceToken.generateJWT({
-            accountId: ownerId,
-            workspaceId: id,
-            role: "owner",
-            workspaceType: params.type,
-          });
-
-          return { workspaceId: id, token, accountId: ownerId };
-        }),
+      (fn) =>
+        fn
+          .withParams({
+            name: string().minLength(1).maxLength(100),
+            type: string(),
+          })
+          .handle(
+            ONLY_SERVER &&
+              (async (ctx, params) => {
+                const id = workspaceId.generate();
+                const ownerMemberId = workspaceMemberId.generate();
+                const ownerId = ctx.$auth.params.accountId;
+
+                await ctx.workspaceCreated.emit({
+                  workspaceId: id,
+                  ownerMemberId,
+                  name: params.name,
+                  type: params.type,
+                  ownerId,
+                });
+
+                const token = workspaceToken.generateJWT({
+                  accountId: ownerId,
+                  workspaceId: id,
+                  role: "owner",
+                  workspaceType: params.type,
+                });
+
+                return { workspaceId: id, token, accountId: ownerId };
+              }),
+          ),
     )
 
     .mutateMethod(
       "rename",
-      {
-        params: {
-          workspaceId,
-          name: string().minLength(1).maxLength(100),
-        },
-      },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const existing = await ctx.$query.findOne({
-            _id: params.workspaceId,
-          });
-          if (!existing) {
-            return { error: "WORKSPACE_NOT_FOUND" as const };
-          }
-
-          await ctx.workspaceRenamed.emit({
-            workspaceId: params.workspaceId,
-            name: params.name,
-          });
-
-          return { success: true };
-        }),
+      (fn) =>
+        fn
+          .withParams({
+            workspaceId,
+            name: string().minLength(1).maxLength(100),
+          })
+          .handle(
+            ONLY_SERVER &&
+              (async (ctx, params) => {
+                const existing = await ctx.$query.findOne({
+                  _id: params.workspaceId,
+                });
+                if (!existing) {
+                  return { error: "WORKSPACE_NOT_FOUND" as const };
+                }
+
+                await ctx.workspaceRenamed.emit({
+                  workspaceId: params.workspaceId,
+                  name: params.name,
+                });
+
+                return { success: true };
+              }),
+          ),
     )
 
-    .publicEvent(
-      "workspaceArchived",
-      { workspaceId },
-      async (ctx, event) => {
-        await ctx.modify(event.payload.workspaceId, {
-          isArchived: true,
-        });
-      },
-    )
+    .publicEvent("workspaceArchived", { workspaceId }, async (ctx, event) => {
+      await ctx.modify(event.payload.workspaceId, {
+        isArchived: true,
+      });
+    })
 
     .mutateMethod(
       "archive",
-      { params: { workspaceId } },
-      ONLY_SERVER &&
-        (async (ctx, params) => {
-          const existing = await ctx.$query.findOne({
-            _id: params.workspaceId,
-          });
-          if (!existing) {
-            return { error: "WORKSPACE_NOT_FOUND" as const };
-          }
-
-          await ctx.workspaceArchived.emit({
-            workspaceId: params.workspaceId,
-          });
-
-          return { success: true };
-        }),
+      (fn) =>
+        fn.withParams({ workspaceId }).handle(
+          ONLY_SERVER &&
+            (async (ctx, params) => {
+              const existing = await ctx.$query.findOne({
+                _id: params.workspaceId,
+              });
+              if (!existing) {
+                return { error: "WORKSPACE_NOT_FOUND" as const };
+              }
+
+              await ctx.workspaceArchived.emit({
+                workspaceId: params.workspaceId,
+              });
+
+              return { success: true };
+            }),
+        ),
     )
 
-    .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
-;
+    .clientQuery("getAll", (fn) => fn.handle(async (ctx) => ctx.$query.find({})));
 };
 
 export type WorkspaceAggregate<

package/src/workspace-builder.ts

@@ -1,6 +1,5 @@
 import {
   context,
-  type ArcAggregateElement,
   type ArcContextElement,
 } from "@arcote.tech/arc";
 import type { AccountId, Token } from "@arcote.tech/arc-auth";
@@ -17,9 +16,9 @@ export class WorkspaceBuilder<
   WsMemberId,
   WsInvId,
   WsToken,
-  Workspace extends ArcAggregateElement,
-  WorkspaceMember extends ArcAggregateElement,
-  WorkspaceInvitation extends ArcAggregateElement,
+  Workspace,
+  WorkspaceMember,
+  WorkspaceInvitation,
   Types extends readonly string[],
   Elements extends ArcContextElement<any>[],
 > {