@shipfox/api-workspaces 2.0.0

package/src/db/memberships.test.ts

@@ -0,0 +1,107 @@
+import {LastMemberError} from '#core/errors.js';
+import {
+  createMembership,
+  findMembership,
+  listMembershipsByUser,
+  listMembershipsByWorkspace,
+  removeMembership,
+} from './memberships.js';
+import {createWorkspace} from './workspaces.js';
+
+function emailFor(suffix: string): string {
+  return `${suffix}-${crypto.randomUUID()}@example.com`;
+}
+
+async function createUser(params: {email: string; hashedPassword?: string; name?: string}) {
+  await Promise.resolve();
+  return {userId: crypto.randomUUID(), email: params.email, name: null};
+}
+
+describe('memberships db', () => {
+  test('creates a membership', async () => {
+    const user = await createUser({email: emailFor('m1'), hashedPassword: 'h'});
+    const workspace = await createWorkspace({name: `Workspace ${crypto.randomUUID()}`});
+
+    const membership = await createMembership({userId: user.userId, workspaceId: workspace.id});
+
+    expect(membership.userId).toBe(user.userId);
+    expect(membership.workspaceId).toBe(workspace.id);
+  });
+
+  test('rejects duplicate (user_id, workspace_id)', async () => {
+    const user = await createUser({email: emailFor('dup'), hashedPassword: 'h'});
+    const workspace = await createWorkspace({name: `Workspace ${crypto.randomUUID()}`});
+    await createMembership({userId: user.userId, workspaceId: workspace.id});
+
+    await expect(
+      createMembership({userId: user.userId, workspaceId: workspace.id}),
+    ).rejects.toThrow();
+  });
+
+  test('lists memberships by user joined with workspace name', async () => {
+    const user = await createUser({email: emailFor('listu'), hashedPassword: 'h'});
+    const workspace = await createWorkspace({name: `Listed-${crypto.randomUUID()}`});
+    await createMembership({userId: user.userId, workspaceId: workspace.id});
+
+    const list = await listMembershipsByUser({userId: user.userId});
+
+    expect(list).toHaveLength(1);
+    expect(list[0]?.workspaceName).toBe(workspace.name);
+  });
+
+  test('lists memberships sorted by workspace name ascending', async () => {
+    const user = await createUser({email: emailFor('order'), hashedPassword: 'h'});
+    const suffix = crypto.randomUUID();
+    const charlie = await createWorkspace({name: `order-${suffix}-Charlie`});
+    const alpha = await createWorkspace({name: `order-${suffix}-Alpha`});
+    const bravo = await createWorkspace({name: `order-${suffix}-Bravo`});
+    await createMembership({userId: user.userId, workspaceId: charlie.id});
+    await createMembership({userId: user.userId, workspaceId: alpha.id});
+    await createMembership({userId: user.userId, workspaceId: bravo.id});
+
+    const list = await listMembershipsByUser({userId: user.userId});
+
+    expect(list.map((m) => m.workspaceName)).toEqual([alpha.name, bravo.name, charlie.name]);
+  });
+
+  test('lists memberships by workspace joined with user info', async () => {
+    const user = await createUser({email: emailFor('listt'), hashedPassword: 'h', name: 'Listy'});
+    const workspace = await createWorkspace({name: `Workspace ${crypto.randomUUID()}`});
+    await createMembership({
+      userId: user.userId,
+      userEmail: user.email,
+      userName: 'Listy',
+      workspaceId: workspace.id,
+    });
+
+    const list = await listMembershipsByWorkspace({workspaceId: workspace.id});
+
+    expect(list).toHaveLength(1);
+    expect(list[0]?.userEmail).toBe(user.email);
+    expect(list[0]?.userName).toBe('Listy');
+  });
+
+  test('removeMembership succeeds when ≥2 members exist', async () => {
+    const userA = await createUser({email: emailFor('a'), hashedPassword: 'h'});
+    const userB = await createUser({email: emailFor('b'), hashedPassword: 'h'});
+    const workspace = await createWorkspace({name: `Workspace ${crypto.randomUUID()}`});
+    await createMembership({userId: userA.userId, workspaceId: workspace.id});
+    await createMembership({userId: userB.userId, workspaceId: workspace.id});
+
+    await removeMembership({userId: userA.userId, workspaceId: workspace.id});
+
+    expect(await findMembership({userId: userA.userId, workspaceId: workspace.id})).toBeUndefined();
+    expect(await findMembership({userId: userB.userId, workspaceId: workspace.id})).toBeDefined();
+  });
+
+  test('removeMembership rejects when only 1 member exists', async () => {
+    const user = await createUser({email: emailFor('only'), hashedPassword: 'h'});
+    const workspace = await createWorkspace({name: `Workspace ${crypto.randomUUID()}`});
+    await createMembership({userId: user.userId, workspaceId: workspace.id});
+
+    await expect(
+      removeMembership({userId: user.userId, workspaceId: workspace.id}),
+    ).rejects.toBeInstanceOf(LastMemberError);
+    expect(await findMembership({userId: user.userId, workspaceId: workspace.id})).toBeDefined();
+  });
+});

package/src/db/memberships.ts

@@ -0,0 +1,139 @@
+import {and, eq, sql} from 'drizzle-orm';
+import type {Membership} from '#core/entities/membership.js';
+import {LastMemberError} from '#core/errors.js';
+import {recordWorkspaceMembershipChanged} from '#metrics/instance.js';
+import {db} from './db.js';
+import {memberships, toMembership} from './schema/memberships.js';
+import {workspaces} from './schema/workspaces.js';
+
+export interface CreateMembershipParams {
+  userId: string;
+  userEmail?: string | undefined;
+  userName?: string | null | undefined;
+  workspaceId: string;
+}
+
+export interface EnsureMembershipParams {
+  userId: string;
+  userEmail: string;
+  userName: string | null;
+  workspaceId: string;
+}
+
+export function membershipValues(params: CreateMembershipParams) {
+  return {
+    userId: params.userId,
+    userEmail: params.userEmail ?? `user-${params.userId}@example.local`,
+    userName: params.userName ?? null,
+    workspaceId: params.workspaceId,
+  };
+}
+
+export async function createMembership(params: CreateMembershipParams): Promise<Membership> {
+  const rows = await db().insert(memberships).values(membershipValues(params)).returning();
+
+  const row = rows[0];
+  if (!row) throw new Error('Insert returned no rows');
+  recordWorkspaceMembershipChanged('added');
+  return toMembership(row);
+}
+
+export async function ensureMembership(params: EnsureMembershipParams): Promise<Membership> {
+  const rows = await db()
+    .insert(memberships)
+    .values(membershipValues(params))
+    .onConflictDoNothing({target: [memberships.userId, memberships.workspaceId]})
+    .returning();
+
+  const row = rows[0];
+  if (row) {
+    recordWorkspaceMembershipChanged('added');
+    return toMembership(row);
+  }
+
+  const existing = await findMembership(params);
+  if (existing) return existing;
+  throw new Error('Membership conflict returned no membership');
+}
+
+export interface MembershipWithWorkspace extends Membership {
+  workspaceName: string;
+}
+
+export async function listMembershipsByUser(params: {
+  userId: string;
+}): Promise<MembershipWithWorkspace[]> {
+  const rows = await db()
+    .select({
+      membership: memberships,
+      workspaceName: workspaces.name,
+    })
+    .from(memberships)
+    .innerJoin(workspaces, eq(workspaces.id, memberships.workspaceId))
+    .where(eq(memberships.userId, params.userId))
+    .orderBy(workspaces.name);
+
+  return rows.map((row) => ({...toMembership(row.membership), workspaceName: row.workspaceName}));
+}
+
+export interface MembershipWithUser extends Membership {
+  userEmail: string;
+  userName: string | null;
+}
+
+export async function listMembershipsByWorkspace(params: {
+  workspaceId: string;
+}): Promise<MembershipWithUser[]> {
+  const rows = await db()
+    .select()
+    .from(memberships)
+    .where(eq(memberships.workspaceId, params.workspaceId));
+
+  return rows.map(toMembership);
+}
+
+export async function findMembership(params: {
+  userId: string;
+  workspaceId: string;
+}): Promise<Membership | undefined> {
+  const rows = await db()
+    .select()
+    .from(memberships)
+    .where(
+      and(eq(memberships.userId, params.userId), eq(memberships.workspaceId, params.workspaceId)),
+    )
+    .limit(1);
+
+  const row = rows[0];
+  if (!row) return undefined;
+  return toMembership(row);
+}
+
+export interface RemoveMembershipParams {
+  userId: string;
+  workspaceId: string;
+}
+
+export async function removeMembership(params: RemoveMembershipParams): Promise<void> {
+  const removed = await db().transaction(async (tx) => {
+    const countResult = await tx
+      .select({count: sql<number>`count(*)::int`})
+      .from(memberships)
+      .where(eq(memberships.workspaceId, params.workspaceId));
+    const total = countResult[0]?.count ?? 0;
+    if (total <= 1) {
+      throw new LastMemberError(params.workspaceId);
+    }
+
+    const deleted = await tx
+      .delete(memberships)
+      .where(
+        and(eq(memberships.userId, params.userId), eq(memberships.workspaceId, params.workspaceId)),
+      )
+      .returning({id: memberships.id});
+
+    return deleted.length > 0;
+  });
+
+  if (removed) recordWorkspaceMembershipChanged('removed');
+}

package/src/db/schema/common.ts

@@ -0,0 +1,5 @@
+import {pgTableCreator} from 'drizzle-orm/pg-core';
+
+export const pgTable = pgTableCreator((name) =>
+  name === 'workspaces' ? name : `workspaces_${name}`,
+);

package/src/db/schema/invitations.ts

@@ -0,0 +1,47 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import type {Invitation} from '#core/entities/invitation.js';
+import {pgTable} from './common.js';
+import {workspaces} from './workspaces.js';
+
+export const invitations = pgTable(
+  'invitations',
+  {
+    id: uuidv7PrimaryKey(),
+    workspaceId: uuid('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, {onDelete: 'cascade'}),
+    email: text('email').notNull(),
+    hashedToken: text('hashed_token').notNull(),
+    expiresAt: timestamp('expires_at', {withTimezone: true}).notNull(),
+    acceptedAt: timestamp('accepted_at', {withTimezone: true}),
+    acceptedByUserId: uuid('accepted_by_user_id'),
+    invitedByUserId: uuid('invited_by_user_id').notNull(),
+    invitedByDisplay: text('invited_by_display'),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('workspaces_invitations_hashed_token_unique').on(table.hashedToken),
+    index('workspaces_invitations_workspace_email_idx').on(table.workspaceId, table.email),
+  ],
+);
+
+export type InvitationDb = typeof invitations.$inferSelect;
+export type InvitationCreateDb = typeof invitations.$inferInsert;
+
+export function toInvitation(row: InvitationDb): Invitation {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    email: row.email,
+    hashedToken: row.hashedToken,
+    expiresAt: row.expiresAt,
+    acceptedAt: row.acceptedAt,
+    acceptedByUserId: row.acceptedByUserId,
+    invitedByUserId: row.invitedByUserId,
+    invitedByDisplay: row.invitedByDisplay,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/db/schema/memberships.ts

@@ -0,0 +1,39 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {index, text, timestamp, uniqueIndex, uuid} from 'drizzle-orm/pg-core';
+import type {Membership} from '#core/entities/membership.js';
+import {pgTable} from './common.js';
+import {workspaces} from './workspaces.js';
+
+export const memberships = pgTable(
+  'memberships',
+  {
+    id: uuidv7PrimaryKey(),
+    userId: uuid('user_id').notNull(),
+    userEmail: text('user_email').notNull(),
+    userName: text('user_name'),
+    workspaceId: uuid('workspace_id')
+      .notNull()
+      .references(() => workspaces.id, {onDelete: 'cascade'}),
+    createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+    updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+  },
+  (table) => [
+    uniqueIndex('workspaces_memberships_user_workspace_unique').on(table.userId, table.workspaceId),
+    index('workspaces_memberships_workspace_id_idx').on(table.workspaceId),
+  ],
+);
+
+export type MembershipDb = typeof memberships.$inferSelect;
+export type MembershipCreateDb = typeof memberships.$inferInsert;
+
+export function toMembership(row: MembershipDb): Membership {
+  return {
+    id: row.id,
+    userId: row.userId,
+    userEmail: row.userEmail,
+    userName: row.userName,
+    workspaceId: row.workspaceId,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/db/schema/outbox.ts

@@ -0,0 +1,4 @@
+import {createOutboxTable} from '@shipfox/node-outbox';
+import {pgTable} from './common.js';
+
+export const workspacesOutbox = createOutboxTable(pgTable);

package/src/db/schema/workspaces.ts

@@ -0,0 +1,33 @@
+import {uuidv7PrimaryKey} from '@shipfox/node-drizzle';
+import {jsonb, pgEnum, text, timestamp} from 'drizzle-orm/pg-core';
+import type {Workspace, WorkspaceStatus} from '#core/entities/workspace.js';
+import {pgTable} from './common.js';
+
+export const workspaceStatusEnum = pgEnum('workspaces_workspace_status', [
+  'active',
+  'suspended',
+  'deleted',
+]);
+
+export const workspaces = pgTable('workspaces', {
+  id: uuidv7PrimaryKey(),
+  name: text('name').notNull(),
+  status: workspaceStatusEnum('status').notNull().default('active'),
+  settings: jsonb('settings').notNull().default({}),
+  createdAt: timestamp('created_at', {withTimezone: true}).notNull().defaultNow(),
+  updatedAt: timestamp('updated_at', {withTimezone: true}).notNull().defaultNow(),
+});
+
+export type WorkspaceDb = typeof workspaces.$inferSelect;
+export type WorkspaceCreateDb = typeof workspaces.$inferInsert;
+
+export function toWorkspace(row: WorkspaceDb): Workspace {
+  return {
+    id: row.id,
+    name: row.name,
+    status: row.status as WorkspaceStatus,
+    settings: row.settings as Record<string, unknown>,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  };
+}

package/src/db/workspaces.test.ts

@@ -0,0 +1,114 @@
+import {acceptInvitation, createInvitation} from './invitations.js';
+import {createMembership} from './memberships.js';
+import {
+  createWorkspace,
+  getWorkspaceById,
+  getWorkspaceServiceMetrics,
+  updateWorkspace,
+} from './workspaces.js';
+
+describe('workspace queries', () => {
+  describe('createWorkspace', () => {
+    test('inserts a workspace with defaults and returns entity', async () => {
+      const workspace = await createWorkspace({name: 'Acme'});
+
+      expect(workspace.id).toBeDefined();
+      expect(workspace.name).toBe('Acme');
+      expect(workspace.status).toBe('active');
+      expect(workspace.settings).toEqual({});
+      expect(workspace.createdAt).toBeInstanceOf(Date);
+      expect(workspace.updatedAt).toBeInstanceOf(Date);
+    });
+  });
+
+  describe('getWorkspaceById', () => {
+    test('returns the workspace when found', async () => {
+      const created = await createWorkspace({name: 'Lookup Test'});
+
+      const found = await getWorkspaceById(created.id);
+
+      expect(found).toBeDefined();
+      expect(found?.id).toBe(created.id);
+      expect(found?.name).toBe('Lookup Test');
+    });
+
+    test('returns undefined when not found', async () => {
+      const found = await getWorkspaceById(crypto.randomUUID());
+
+      expect(found).toBeUndefined();
+    });
+  });
+
+  describe('updateWorkspace', () => {
+    test('updates only provided fields', async () => {
+      const created = await createWorkspace({name: 'Before'});
+
+      const updated = await updateWorkspace({id: created.id, name: 'After'});
+
+      expect(updated).toBeDefined();
+      expect(updated?.name).toBe('After');
+      expect(updated?.updatedAt.getTime()).toBeGreaterThanOrEqual(created.updatedAt.getTime());
+    });
+
+    test('updates status', async () => {
+      const created = await createWorkspace({name: 'Status Update'});
+
+      const updated = await updateWorkspace({id: created.id, status: 'suspended'});
+
+      expect(updated?.status).toBe('suspended');
+    });
+
+    test('returns undefined for non-existent workspace', async () => {
+      const result = await updateWorkspace({id: crypto.randomUUID(), name: 'Ghost'});
+
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('getWorkspaceServiceMetrics', () => {
+    test('counts current workspace service state', async () => {
+      const activeWorkspace = await createWorkspace({
+        name: `Metrics Active ${crypto.randomUUID()}`,
+      });
+      await createMembership({
+        userId: crypto.randomUUID(),
+        workspaceId: activeWorkspace.id,
+      });
+      const openInvitation = await createInvitation({
+        workspaceId: activeWorkspace.id,
+        email: `open-${crypto.randomUUID()}@example.com`,
+        hashedToken: `open-${crypto.randomUUID()}`,
+        expiresAt: new Date(Date.now() + 60_000),
+        invitedByUserId: crypto.randomUUID(),
+        skipEmail: true,
+      });
+      const acceptedInvitation = await createInvitation({
+        workspaceId: activeWorkspace.id,
+        email: `accepted-${crypto.randomUUID()}@example.com`,
+        hashedToken: `accepted-${crypto.randomUUID()}`,
+        expiresAt: new Date(Date.now() + 60_000),
+        invitedByUserId: crypto.randomUUID(),
+        skipEmail: true,
+      });
+      await createInvitation({
+        workspaceId: activeWorkspace.id,
+        email: `expired-${crypto.randomUUID()}@example.com`,
+        hashedToken: `expired-${crypto.randomUUID()}`,
+        expiresAt: new Date(Date.now() - 60_000),
+        invitedByUserId: crypto.randomUUID(),
+        skipEmail: true,
+      });
+      await acceptInvitation({
+        invitationId: acceptedInvitation.id,
+        acceptedByUserId: crypto.randomUUID(),
+      });
+
+      const metrics = await getWorkspaceServiceMetrics();
+
+      expect(openInvitation.acceptedAt).toBeNull();
+      expect(metrics.activeWorkspaces).toBeGreaterThanOrEqual(1);
+      expect(metrics.memberships).toBeGreaterThanOrEqual(2);
+      expect(metrics.openInvitations).toBeGreaterThanOrEqual(1);
+    });
+  });
+});

package/src/db/workspaces.ts

@@ -0,0 +1,81 @@
+import {and, count, eq, gt, isNull, sql} from 'drizzle-orm';
+import type {Workspace, WorkspaceStatus} from '#core/entities/workspace.js';
+import {recordWorkspaceCreated} from '#metrics/instance.js';
+import {db} from './db.js';
+import {invitations} from './schema/invitations.js';
+import {memberships} from './schema/memberships.js';
+import {toWorkspace, workspaces} from './schema/workspaces.js';
+
+export interface CreateWorkspaceParams {
+  name: string;
+}
+
+export async function createWorkspace(params: CreateWorkspaceParams): Promise<Workspace> {
+  const rows = await db()
+    .insert(workspaces)
+    .values({
+      name: params.name,
+    })
+    .returning();
+
+  const row = rows[0];
+  if (!row) throw new Error('Insert returned no rows');
+  recordWorkspaceCreated();
+  return toWorkspace(row);
+}
+
+export interface UpdateWorkspaceParams {
+  id: string;
+  name?: string | undefined;
+  status?: WorkspaceStatus | undefined;
+  settings?: Record<string, unknown> | undefined;
+}
+
+export async function updateWorkspace(
+  params: UpdateWorkspaceParams,
+): Promise<Workspace | undefined> {
+  const set: Record<string, unknown> = {updatedAt: sql`NOW()`};
+  if (params.name !== undefined) set.name = params.name;
+  if (params.status !== undefined) set.status = params.status;
+  if (params.settings !== undefined) set.settings = params.settings;
+
+  const rows = await db()
+    .update(workspaces)
+    .set(set)
+    .where(eq(workspaces.id, params.id))
+    .returning();
+
+  const row = rows[0];
+  if (!row) return undefined;
+  return toWorkspace(row);
+}
+
+export async function getWorkspaceById(id: string): Promise<Workspace | undefined> {
+  const rows = await db().select().from(workspaces).where(eq(workspaces.id, id)).limit(1);
+  const row = rows[0];
+  if (!row) return undefined;
+  return toWorkspace(row);
+}
+
+export interface WorkspaceServiceMetrics {
+  activeWorkspaces: number;
+  memberships: number;
+  openInvitations: number;
+}
+
+export async function getWorkspaceServiceMetrics(): Promise<WorkspaceServiceMetrics> {
+  const [workspaceRows, membershipRows, invitationRows] = await Promise.all([
+    db().select({value: count()}).from(workspaces).where(eq(workspaces.status, 'active')),
+    db().select({value: count()}).from(memberships),
+    db()
+      .select({value: count()})
+      .from(invitations)
+      .where(and(isNull(invitations.acceptedAt), gt(invitations.expiresAt, sql`now()`))),
+  ]);
+
+  return {
+    activeWorkspaces: workspaceRows[0]?.value ?? 0,
+    memberships: membershipRows[0]?.value ?? 0,
+    openInvitations: invitationRows[0]?.value ?? 0,
+  };
+}

package/src/index.test.ts

@@ -0,0 +1,25 @@
+import {
+  WORKSPACES_INVITATION_SEND_REQUESTED,
+  workspacesEventSchemas,
+} from '@shipfox/api-workspaces-dto';
+import {workspacesModule} from './index.js';
+
+vi.mock('#config.js', () => ({
+  config: {
+    CLIENT_BASE_URL: 'https://app.example.test',
+  },
+  mailer: {send: vi.fn()},
+}));
+
+describe('workspacesModule', () => {
+  test('registers workspace invitation outbox publisher and subscriber', () => {
+    const publisher = workspacesModule.publishers?.find((pub) => pub.name === 'workspaces');
+    const events = workspacesModule.subscribers?.map((subscriber) => subscriber.event);
+
+    expect(publisher?.eventSchemas).toBe(workspacesEventSchemas);
+    expect(Object.keys(publisher?.eventSchemas ?? {})).toEqual([
+      WORKSPACES_INVITATION_SEND_REQUESTED,
+    ]);
+    expect(events).toContain(WORKSPACES_INVITATION_SEND_REQUESTED);
+  });
+});

package/src/index.ts

@@ -0,0 +1,43 @@
+import {
+  WORKSPACES_INVITATION_SEND_REQUESTED,
+  type WorkspacesEventMap,
+  workspacesEventSchemas,
+} from '@shipfox/api-workspaces-dto';
+import type {ShipfoxModule} from '@shipfox/node-module';
+import {subscriberFactory} from '@shipfox/node-module';
+import {db, migrationsPath, workspacesOutbox} from '#db/index.js';
+import {registerWorkspacesServiceMetrics} from '#metrics/index.js';
+import {workspacesE2eRoutes} from '#presentation/e2eRoutes/index.js';
+import {workspacesRoutes} from '#presentation/routes/index.js';
+import {onInvitationSendRequested} from '#presentation/subscribers/index.js';
+
+export type {Invitation} from '#core/entities/invitation.js';
+export type {Membership} from '#core/entities/membership.js';
+export type {Workspace, WorkspaceStatus} from '#core/entities/workspace.js';
+export {
+  InvitationEmailMismatchError,
+  TokenAlreadyUsedError,
+  TokenExpiredError,
+  TokenInvalidError,
+  WorkspaceNotFoundError,
+} from '#core/errors.js';
+export {acceptWorkspaceInvitation, peekInvitationByRawToken} from '#core/invitations.js';
+export {type EnsureMembershipParams, ensureMembership} from '#core/memberships.js';
+export {getWorkspace, requireWorkspaceMembership} from '#core/workspaces.js';
+export {db, migrationsPath} from '#db/index.js';
+export {listMembershipsByUser} from '#db/memberships.js';
+export {workspacesRoutes as routes} from '#presentation/routes/index.js';
+
+const subscriber = subscriberFactory<WorkspacesEventMap>();
+
+export const workspacesModule: ShipfoxModule = {
+  name: 'workspaces',
+  database: {db, migrationsPath},
+  routes: workspacesRoutes,
+  e2eRoutes: [workspacesE2eRoutes],
+  publishers: [
+    {name: 'workspaces', table: workspacesOutbox, db, eventSchemas: workspacesEventSchemas},
+  ],
+  subscribers: [subscriber(WORKSPACES_INVITATION_SEND_REQUESTED, onInvitationSendRequested)],
+  metrics: registerWorkspacesServiceMetrics,
+};

package/src/metrics/index.ts

@@ -0,0 +1 @@
+export {registerWorkspacesServiceMetrics} from './service.js';