@arcote.tech/arc-workspace 0.4.1

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@arcote.tech/arc-workspace",
+  "type": "module",
+  "version": "0.4.1",
+  "private": false,
+  "description": "Reusable workspace module for Arc framework — multi-workspace with dual token architecture",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "scripts": {
+    "type-check": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "@arcote.tech/arc": "workspace:*",
+    "@arcote.tech/arc-auth": "workspace:*",
+    "typescript": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/aggregates/workspace-member.ts

@@ -0,0 +1,218 @@
+import {
+  aggregate,
+  date,
+  string,
+  type AggregateConstructorAny,
+  type ArcId,
+} from "@arcote.tech/arc";
+import type { Token } from "@arcote.tech/arc-auth";
+import type { WorkspaceToken } from "../tokens/workspace-token";
+
+export type WorkspaceMemberAggregateData = {
+  name: string;
+  workspaceMemberId: ArcId<any>;
+  workspaceId: ArcId<any>;
+  accountId: ArcId<any>;
+  workspaceToken: WorkspaceToken;
+  userToken: Token;
+  WorkspaceAggregate: AggregateConstructorAny;
+};
+
+export const createWorkspaceMemberAggregate = <
+  const Data extends WorkspaceMemberAggregateData,
+>(
+  data: Data,
+) => {
+  const {
+    workspaceMemberId,
+    workspaceId,
+    accountId,
+    workspaceToken,
+    userToken,
+    WorkspaceAggregate,
+  } = data;
+
+  const workspaceCreatedEvent = WorkspaceAggregate.getEvent("workspaceCreated");
+
+  const Constructor = aggregate(
+    `${data.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,
+      });
+    })
+
+    .mutateMethod(
+      "addMember",
+      {
+        params: {
+          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({
+            workspaceMemberId: id,
+            workspaceId: params.workspaceId,
+            accountId: params.accountId,
+            role: params.role,
+            workspaceName: params.workspaceName,
+            workspaceType: params.workspaceType,
+          });
+
+          return { workspaceMemberId: id };
+        }),
+    )
+
+    .mutateMethod(
+      "removeMember",
+      { params: { workspaceMemberId } },
+      ONLY_SERVER &&
+        (async (ctx, params) => {
+          await ctx.workspaceMemberRemoved.emit({
+            workspaceMemberId: params.workspaceMemberId,
+          });
+        }),
+    )
+
+    .mutateMethod(
+      "changeRole",
+      {
+        params: {
+          workspaceMemberId,
+          role: string(),
+        },
+      },
+      ONLY_SERVER &&
+        (async (ctx, params) => {
+          await ctx.workspaceMemberRoleChanged.emit({
+            workspaceMemberId: params.workspaceMemberId,
+            role: params.role,
+          });
+        }),
+    )
+
+    .mutateMethod(
+      "switchWorkspace",
+      { params: { workspaceMemberId } },
+      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 };
+          }
+
+          const token = workspaceToken.generateJWT({
+            accountId: member.accountId,
+            workspaceId: member.workspaceId,
+            role: member.role,
+            workspaceType: member.workspaceType,
+          });
+
+          return { token };
+        }),
+    )
+
+    .protectBy(userToken, (params: any) => ({ accountId: params.accountId }))
+    .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
+    .build();
+
+  class WorkspaceMember extends Constructor {}
+
+  return WorkspaceMember;
+};
+
+export type WorkspaceMemberAggregate<
+  Data extends WorkspaceMemberAggregateData = WorkspaceMemberAggregateData,
+> = ReturnType<typeof createWorkspaceMemberAggregate<Data>>;

package/src/aggregates/workspace.ts

@@ -0,0 +1,123 @@
+import { aggregate, date, string, type ArcId } from "@arcote.tech/arc";
+import type { WorkspaceToken } from "../tokens/workspace-token";
+
+export type WorkspaceAggregateData = {
+  name: string;
+  workspaceId: ArcId<any>;
+  workspaceMemberId: ArcId<any>;
+  accountId: ArcId<any>;
+  workspaceToken: WorkspaceToken;
+};
+
+export const createWorkspaceAggregate = <
+  const Data extends WorkspaceAggregateData,
+>(
+  data: Data,
+) => {
+  const { workspaceId, workspaceMemberId, accountId, workspaceToken } = data;
+
+  return aggregate(`${data.name}Workspaces`, workspaceId, {
+    name: string().minLength(1).maxLength(100),
+    type: string(),
+    ownerId: accountId,
+    createdAt: date(),
+  })
+    .publicEvent(
+      "workspaceCreated",
+      {
+        workspaceId,
+        ownerMemberId: workspaceMemberId,
+        name: string().minLength(1).maxLength(100),
+        type: string(),
+        ownerId: accountId,
+      },
+      async (ctx, event) => {
+        const { workspaceId: id, name, type, ownerId } = event.payload;
+        await ctx.set(id, {
+          name,
+          type,
+          ownerId,
+          createdAt: event.createdAt,
+        });
+      },
+    )
+
+    .publicEvent(
+      "workspaceRenamed",
+      {
+        workspaceId,
+        name: string().minLength(1).maxLength(100),
+      },
+      async (ctx, event) => {
+        await ctx.modify(event.payload.workspaceId, {
+          name: event.payload.name,
+        });
+      },
+    )
+
+    .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 };
+        }),
+    )
+
+    .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 };
+        }),
+    )
+
+    .clientQuery("getAll", async (ctx) => ctx.$query.find({}))
+    .build();
+};
+
+export type WorkspaceAggregate<
+  Data extends WorkspaceAggregateData = WorkspaceAggregateData,
+> = ReturnType<typeof createWorkspaceAggregate<Data>>;

package/src/arc.d.ts

@@ -0,0 +1,6 @@
+declare const BROWSER: boolean;
+declare const NOT_ON_BROWSER: boolean;
+declare const ONLY_BROWSER: boolean;
+declare const SERVER: boolean;
+declare const NOT_ON_SERVER: boolean;
+declare const ONLY_SERVER: boolean;

package/src/ids/workspace-member.ts

@@ -0,0 +1,15 @@
+import { id } from "@arcote.tech/arc";
+
+export type WorkspaceMemberIdData = {
+  name: string;
+};
+
+export const createWorkspaceMemberId = <
+  const Data extends WorkspaceMemberIdData,
+>(
+  data: Readonly<Data>,
+) => id(`${data.name}WorkspaceMember`);
+
+export type WorkspaceMemberId<
+  Data extends WorkspaceMemberIdData = WorkspaceMemberIdData,
+> = ReturnType<typeof createWorkspaceMemberId<Data>>;

package/src/ids/workspace.ts

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

package/src/index.ts

@@ -0,0 +1,18 @@
+// --- Builder API ---
+export { workspace, WorkspaceBuilder } from "./workspace-builder";
+
+// --- Aggregate factories & types ---
+export { createWorkspaceAggregate } from "./aggregates/workspace";
+export type { WorkspaceAggregate } from "./aggregates/workspace";
+export { createWorkspaceMemberAggregate } from "./aggregates/workspace-member";
+export type { WorkspaceMemberAggregate } from "./aggregates/workspace-member";
+
+// --- 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";
+
+// --- Token factory & type ---
+export { createWorkspaceToken } from "./tokens/workspace-token";
+export type { WorkspaceToken } from "./tokens/workspace-token";

package/src/tokens/workspace-token.ts

@@ -0,0 +1,20 @@
+import { string, token } from "@arcote.tech/arc";
+
+export type WorkspaceTokenData = {
+  name: string;
+  secret: string | undefined;
+};
+
+export const createWorkspaceToken = <const Data extends WorkspaceTokenData>(
+  data: Data,
+) =>
+  token(`${data.name}Workspace`, {
+    accountId: string(),
+    workspaceId: string(),
+    role: string(),
+    workspaceType: string(),
+  }).secret(data.secret);
+
+export type WorkspaceToken<
+  Data extends WorkspaceTokenData = WorkspaceTokenData,
+> = ReturnType<typeof createWorkspaceToken<Data>>;

package/src/workspace-builder.ts

@@ -0,0 +1,110 @@
+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 { createWorkspaceToken } from "./tokens/workspace-token";
+import { createWorkspaceAggregate } from "./aggregates/workspace";
+import { createWorkspaceMemberAggregate } from "./aggregates/workspace-member";
+
+export class WorkspaceBuilder<
+  WsId,
+  WsMemberId,
+  WsToken,
+  Workspace extends AggregateConstructorAny,
+  WorkspaceEl extends ArcAggregateElement<Workspace>,
+  WorkspaceMember extends AggregateConstructorAny,
+  WorkspaceMemberEl extends ArcAggregateElement<WorkspaceMember>,
+  Types extends readonly string[],
+  Elements extends ArcContextElement<any>[],
+> {
+  constructor(
+    private readonly _name: string,
+    readonly workspaceId: WsId,
+    readonly workspaceMemberId: WsMemberId,
+    readonly workspaceToken: WsToken,
+    readonly Workspace: Workspace,
+    readonly workspaceElement: WorkspaceEl,
+    readonly WorkspaceMember: WorkspaceMember,
+    readonly workspaceMemberElement: WorkspaceMemberEl,
+    readonly types: Types,
+    readonly elements: Elements,
+  ) {}
+
+  build() {
+    return {
+      context: context(this.elements),
+      workspaceId: this.workspaceId,
+      workspaceMemberId: this.workspaceMemberId,
+      workspaceToken: this.workspaceToken,
+      Workspace: this.Workspace,
+      WorkspaceMember: this.WorkspaceMember,
+      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,
+    };
+  }
+}
+
+export function workspace<
+  const Name extends string,
+  const Types extends readonly string[],
+  const Secret extends string | undefined,
+>(config: {
+  name: Name;
+  types: Types;
+  secret: Secret;
+  accountId: AccountId;
+  userToken: Token;
+}) {
+  const workspaceId = createWorkspaceId({ name: config.name });
+  const workspaceMemberId = createWorkspaceMemberId({ name: config.name });
+  const workspaceToken = createWorkspaceToken({
+    name: config.name,
+    secret: config.secret,
+  });
+
+  const Workspace = createWorkspaceAggregate({
+    name: config.name,
+    workspaceId,
+    workspaceMemberId,
+    accountId: config.accountId,
+    workspaceToken,
+  });
+  const workspaceElement = aggregateContextElement(Workspace);
+
+  const WorkspaceMember = createWorkspaceMemberAggregate({
+    name: config.name,
+    workspaceMemberId,
+    workspaceId,
+    accountId: config.accountId,
+    workspaceToken,
+    userToken: config.userToken,
+    WorkspaceAggregate: Workspace,
+  });
+  const workspaceMemberElement = aggregateContextElement(WorkspaceMember);
+
+  const elements = [workspaceElement, workspaceMemberElement];
+
+  return new WorkspaceBuilder(
+    config.name,
+    workspaceId,
+    workspaceMemberId,
+    workspaceToken,
+    Workspace,
+    workspaceElement,
+    WorkspaceMember,
+    workspaceMemberElement,
+    config.types,
+    elements,
+  );
+}

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src/**/*"]
+}