@arcote.tech/arc-workspace 0.4.6 → 0.4.8

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcote.tech/arc-workspace",
   "type": "module",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "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.6",
-    "@arcote.tech/arc-auth": "^0.4.6",
+    "@arcote.tech/arc": "^0.4.8",
+    "@arcote.tech/arc-auth": "^0.4.8",
     "typescript": "^5.0.0"
   },
   "devDependencies": {

package/src/aggregates/workspace-invitation.ts

@@ -0,0 +1,219 @@
+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";
+
+export type WorkspaceInvitationAggregateData = {
+  name: string;
+  workspaceInvitationId: ArcId<any>;
+  workspaceId: ArcId<any>;
+  accountId: ArcId<any>;
+  workspaceToken: WorkspaceToken;
+  userToken: Token;
+};
+
+function generateInviteToken(): string {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 32; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+export const createWorkspaceInvitationAggregate = <
+  const Data extends WorkspaceInvitationAggregateData,
+>(
+  data: Data,
+) => {
+  const {
+    workspaceInvitationId,
+    workspaceId,
+    accountId,
+    workspaceToken,
+    userToken,
+  } = data;
+
+  return aggregate(
+    `${data.name}WorkspaceInvitations`,
+    workspaceInvitationId,
+    {
+      workspaceId,
+      invitedBy: accountId,
+      role: string(),
+      token: string(),
+      email: string().optional(),
+      workspaceName: string(),
+      workspaceType: string(),
+      status: string(), // "pending" | "accepted" | "revoked"
+      createdAt: date(),
+      expiresAt: date(),
+    },
+  )
+    .publicEvent(
+      "invitationCreated",
+      {
+        workspaceInvitationId,
+        workspaceId,
+        invitedBy: accountId,
+        role: string(),
+        token: string(),
+        email: string().optional(),
+        workspaceName: string(),
+        workspaceType: string(),
+        expiresAt: date(),
+      },
+      async (ctx, event) => {
+        const p = event.payload;
+        await ctx.set(p.workspaceInvitationId, {
+          workspaceId: p.workspaceId,
+          invitedBy: p.invitedBy,
+          role: p.role,
+          token: p.token,
+          email: p.email,
+          workspaceName: p.workspaceName,
+          workspaceType: p.workspaceType,
+          status: "pending",
+          createdAt: event.createdAt,
+          expiresAt: p.expiresAt,
+        });
+      },
+    )
+
+    .publicEvent(
+      "invitationAccepted",
+      {
+        workspaceInvitationId,
+        workspaceId,
+        acceptedBy: accountId,
+        role: string(),
+        workspaceName: string(),
+        workspaceType: string(),
+      },
+      async (ctx, event) => {
+        await ctx.modify(event.payload.workspaceInvitationId, {
+          status: "accepted",
+        });
+      },
+    )
+
+    .publicEvent(
+      "invitationRevoked",
+      { workspaceInvitationId },
+      async (ctx, event) => {
+        await ctx.modify(event.payload.workspaceInvitationId, {
+          status: "revoked",
+        });
+      },
+    )
+
+    .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 };
+        }),
+    )
+
+    .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,
+          };
+        }),
+    )
+
+    .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 };
+        }),
+    )
+
+    .protectBy(userToken, (p: any) => ({ invitedBy: p.accountId }))
+    .clientQuery("getByWorkspace", async (ctx) => ctx.$query.find({}))
+  ;
+};
+
+export type WorkspaceInvitationAggregate<
+  Data extends WorkspaceInvitationAggregateData = WorkspaceInvitationAggregateData,
+> = ReturnType<typeof createWorkspaceInvitationAggregate<Data>>;

package/src/aggregates/workspace-member.ts

@@ -2,7 +2,7 @@ import {
   aggregate,
   date,
   string,
-  type AggregateConstructorAny,
+  type ArcAggregateElement,
   type ArcId,
 } from "@arcote.tech/arc";
 import type { Token } from "@arcote.tech/arc-auth";
@@ -15,7 +15,8 @@ export type WorkspaceMemberAggregateData = {
   accountId: ArcId<any>;
   workspaceToken: WorkspaceToken;
   userToken: Token;
-  WorkspaceAggregate: AggregateConstructorAny;
+  WorkspaceAggregate: ArcAggregateElement<any, any, any, any, any, any>;
+  WorkspaceInvitationAggregate?: ArcAggregateElement<any, any, any, any, any, any>;
 };
 
 export const createWorkspaceMemberAggregate = <
@@ -30,11 +31,12 @@ export const createWorkspaceMemberAggregate = <
     workspaceToken,
     userToken,
     WorkspaceAggregate,
+    WorkspaceInvitationAggregate,
   } = data;
 
   const workspaceCreatedEvent = WorkspaceAggregate.getEvent("workspaceCreated");
 
-  const Constructor = aggregate(
+  let Constructor = aggregate(
     `${data.name}WorkspaceMembers`,
     workspaceMemberId,
     {
@@ -109,7 +111,48 @@ export const createWorkspaceMemberAggregate = <
       });
     })
 
-    .mutateMethod(
+    // 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: {
@@ -205,12 +248,12 @@ export const createWorkspaceMemberAggregate = <
     )
 
     .protectBy(userToken, (params: any) => ({ accountId: params.accountId }))
+    .protectBy(workspaceToken, (params: any) => ({ workspaceId: params.workspaceId }))
     .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
-    .build();
-
-  class WorkspaceMember extends Constructor {}
+    .clientQuery("getByWorkspace", async (ctx) => ctx.$query.find({}))
+;
 
-  return WorkspaceMember;
+  return Constructor;
 };
 
 export type WorkspaceMemberAggregate<

package/src/aggregates/workspace.ts

@@ -1,4 +1,4 @@
-import { aggregate, date, string, type ArcId } from "@arcote.tech/arc";
+import { aggregate, boolean, date, string, type ArcId } from "@arcote.tech/arc";
 import type { WorkspaceToken } from "../tokens/workspace-token";
 
 export type WorkspaceAggregateData = {
@@ -20,6 +20,7 @@ export const createWorkspaceAggregate = <
     name: string().minLength(1).maxLength(100),
     type: string(),
     ownerId: accountId,
+    isArchived: boolean(),
     createdAt: date(),
   })
     .publicEvent(
@@ -37,6 +38,7 @@ export const createWorkspaceAggregate = <
           name,
           type,
           ownerId,
+          isArchived: false,
           createdAt: event.createdAt,
         });
       },
@@ -114,8 +116,38 @@ export const createWorkspaceAggregate = <
         }),
     )
 
+    .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 };
+        }),
+    )
+
     .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
-    .build();
+;
 };
 
 export type WorkspaceAggregate<

package/src/ids/workspace-invitation.ts

@@ -0,0 +1,12 @@
+import { id } from "@arcote.tech/arc";
+
+export type WorkspaceInvitationIdData = {
+  name: string;
+};
+
+export const createWorkspaceInvitationId = <const Data extends WorkspaceInvitationIdData>(
+  data: Readonly<Data>,
+) => id(`${data.name}WorkspaceInvitation`);
+
+export type WorkspaceInvitationId<Data extends WorkspaceInvitationIdData = WorkspaceInvitationIdData> =
+  ReturnType<typeof createWorkspaceInvitationId<Data>>;

package/src/index.ts

@@ -6,12 +6,16 @@ export { createWorkspaceAggregate } from "./aggregates/workspace";
 export type { WorkspaceAggregate } from "./aggregates/workspace";
 export { createWorkspaceMemberAggregate } from "./aggregates/workspace-member";
 export type { WorkspaceMemberAggregate } from "./aggregates/workspace-member";
+export { createWorkspaceInvitationAggregate } from "./aggregates/workspace-invitation";
+export type { WorkspaceInvitationAggregate } from "./aggregates/workspace-invitation";
 
 // --- ID factories & types ---
 export { createWorkspaceId } from "./ids/workspace";
 export type { WorkspaceId } from "./ids/workspace";
 export { createWorkspaceMemberId } from "./ids/workspace-member";
 export type { WorkspaceMemberId } from "./ids/workspace-member";
+export { createWorkspaceInvitationId } from "./ids/workspace-invitation";
+export type { WorkspaceInvitationId } from "./ids/workspace-invitation";
 
 // --- Token factory & type ---
 export { createWorkspaceToken } from "./tokens/workspace-token";

package/src/workspace-builder.ts

@@ -1,25 +1,25 @@
 import {
-  aggregateContextElement,
   context,
   type ArcAggregateElement,
   type ArcContextElement,
-  type AggregateConstructorAny,
 } from "@arcote.tech/arc";
 import type { AccountId, Token } from "@arcote.tech/arc-auth";
 import { createWorkspaceId } from "./ids/workspace";
 import { createWorkspaceMemberId } from "./ids/workspace-member";
+import { createWorkspaceInvitationId } from "./ids/workspace-invitation";
 import { createWorkspaceToken } from "./tokens/workspace-token";
 import { createWorkspaceAggregate } from "./aggregates/workspace";
 import { createWorkspaceMemberAggregate } from "./aggregates/workspace-member";
+import { createWorkspaceInvitationAggregate } from "./aggregates/workspace-invitation";
 
 export class WorkspaceBuilder<
   WsId,
   WsMemberId,
+  WsInvId,
   WsToken,
-  Workspace extends AggregateConstructorAny,
-  WorkspaceEl extends ArcAggregateElement<Workspace>,
-  WorkspaceMember extends AggregateConstructorAny,
-  WorkspaceMemberEl extends ArcAggregateElement<WorkspaceMember>,
+  Workspace extends ArcAggregateElement,
+  WorkspaceMember extends ArcAggregateElement,
+  WorkspaceInvitation extends ArcAggregateElement,
   Types extends readonly string[],
   Elements extends ArcContextElement<any>[],
 > {
@@ -27,11 +27,11 @@ export class WorkspaceBuilder<
     private readonly _name: string,
     readonly workspaceId: WsId,
     readonly workspaceMemberId: WsMemberId,
+    readonly workspaceInvitationId: WsInvId,
     readonly workspaceToken: WsToken,
     readonly Workspace: Workspace,
-    readonly workspaceElement: WorkspaceEl,
     readonly WorkspaceMember: WorkspaceMember,
-    readonly workspaceMemberElement: WorkspaceMemberEl,
+    readonly WorkspaceInvitation: WorkspaceInvitation,
     readonly types: Types,
     readonly elements: Elements,
   ) {}
@@ -41,16 +41,17 @@ export class WorkspaceBuilder<
       context: context(this.elements),
       workspaceId: this.workspaceId,
       workspaceMemberId: this.workspaceMemberId,
+      workspaceInvitationId: this.workspaceInvitationId,
       workspaceToken: this.workspaceToken,
       Workspace: this.Workspace,
       WorkspaceMember: this.WorkspaceMember,
+      WorkspaceInvitation: this.WorkspaceInvitation,
       types: this.types,
-      // Protection helpers
       isOwner: (params: { role: string }) => params.role === "owner",
       isMember: (params: { role: string }) =>
         params.role === "member" || params.role === "owner",
-      isType: (type: string) => (params: { workspaceType: string }) =>
-        params.workspaceType === type,
+      isType: (...types: string[]) => (token: { params?: { workspaceType?: string } }) =>
+        types.includes(token.params?.workspaceType ?? ""),
     };
   }
 }
@@ -68,6 +69,7 @@ export function workspace<
 }) {
   const workspaceId = createWorkspaceId({ name: config.name });
   const workspaceMemberId = createWorkspaceMemberId({ name: config.name });
+  const workspaceInvitationId = createWorkspaceInvitationId({ name: config.name });
   const workspaceToken = createWorkspaceToken({
     name: config.name,
     secret: config.secret,
@@ -80,7 +82,15 @@ export function workspace<
     accountId: config.accountId,
     workspaceToken,
   });
-  const workspaceElement = aggregateContextElement(Workspace);
+
+  const WorkspaceInvitation = createWorkspaceInvitationAggregate({
+    name: config.name,
+    workspaceInvitationId,
+    workspaceId,
+    accountId: config.accountId,
+    workspaceToken,
+    userToken: config.userToken,
+  });
 
   const WorkspaceMember = createWorkspaceMemberAggregate({
     name: config.name,
@@ -90,21 +100,19 @@ export function workspace<
     workspaceToken,
     userToken: config.userToken,
     WorkspaceAggregate: Workspace,
+    WorkspaceInvitationAggregate: WorkspaceInvitation,
   });
-  const workspaceMemberElement = aggregateContextElement(WorkspaceMember);
-
-  const elements = [workspaceElement, workspaceMemberElement];
 
   return new WorkspaceBuilder(
     config.name,
     workspaceId,
     workspaceMemberId,
+    workspaceInvitationId,
     workspaceToken,
     Workspace,
-    workspaceElement,
     WorkspaceMember,
-    workspaceMemberElement,
+    WorkspaceInvitation,
     config.types,
-    elements,
+    [Workspace, WorkspaceMember, WorkspaceInvitation],
   );
 }