@cyberismo/backend 1.1.2 → 1.3.0

package/src/domain/events/lifetime.ts

@@ -0,0 +1,17 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+const MAX_LIFETIME_MS = 30 * 60_000;
+const ROTATION_MARGIN_MS = 30_000;
+
+/** Rotation deadline in ms from now. */
+export function computeLifetimeMs(exp: number, now = Date.now()): number {
+  const jittered = MAX_LIFETIME_MS * (0.6 + Math.random() * 0.4);
+  const remaining = exp * 1000 - now;
+  // Jitter may only shorten: the token `exp` clamp is hard.
+  const untilExpiry =
+    remaining > ROTATION_MARGIN_MS
+      ? remaining - ROTATION_MARGIN_MS
+      : Math.max(remaining, 0);
+  return Math.min(untilExpiry, jittered);
+}

package/src/domain/events/project-events.ts

@@ -0,0 +1,266 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { randomUUID } from 'node:crypto';
+import type { SSEMessage } from 'hono/streaming';
+import type { ActorRef, ChangeEvent } from '@cyberismo/model';
+
+const LEASE_MS = 90_000;
+const EXPIRY_INTERVAL_MS = 30_000;
+const RETIRED_LEASE_MS = 15_000;
+
+export interface PresenceEntry {
+  userId: string;
+  userName: string;
+  mode: 'viewing' | 'editing';
+}
+
+export interface Capabilities {
+  canSeeIdentity: boolean;
+  canDeclareEditing: boolean;
+  canSeePresence: boolean;
+}
+
+/** The socket one connection's client is written to. A retired connection
+ * must not be written to at all; `deliver` and `closeQuietly` enforce that,
+ * since the route has already ended the stream by then. */
+export interface Delivery {
+  send(message: SSEMessage): void;
+  close(): void;
+  terminate(message: SSEMessage): void;
+}
+
+interface Connection {
+  user: { id: string; name: string };
+  capabilities: Capabilities;
+  delivery: Delivery;
+  cardKey: string | null;
+  mode: PresenceEntry['mode'];
+  sequence: number;
+  expiresAt: number;
+  retired: boolean;
+  /** Last presence list serialized to this connection, for per-recipient dedup. */
+  lastSent: string | null;
+}
+
+/** Where a project's change events come from. */
+export interface ChangeSource {
+  subscribe(listener: (event: ChangeEvent) => void): () => void;
+}
+
+/** The open subscriptions of one project and the presence leases they hold. */
+export class ProjectEvents {
+  private connections = new Map<string, Connection>();
+  private expiryTimer: ReturnType<typeof setInterval>;
+  private unsubscribe: () => void;
+
+  /** Announces the cards each of `changes`' events names, whoever wrote them. */
+  constructor(changes?: ChangeSource) {
+    this.expiryTimer = setInterval(() => this.expire(), EXPIRY_INTERVAL_MS);
+    this.expiryTimer.unref();
+    this.unsubscribe =
+      changes?.subscribe((event) => this.changed(event)) ?? (() => {});
+  }
+
+  connect(
+    user: Connection['user'],
+    capabilities: Capabilities,
+    delivery: Delivery,
+  ): string {
+    const connectionId = randomUUID();
+    this.connections.set(connectionId, {
+      user,
+      capabilities,
+      delivery,
+      cardKey: null,
+      mode: 'viewing',
+      sequence: -1,
+      expiresAt: 0,
+      retired: false,
+      lastSent: null,
+    });
+    // EventSource cannot read response headers, so the stream is the only
+    // way back with a connection handle.
+    this.deliver(connectionId, {
+      event: 'ready',
+      data: JSON.stringify({ connectionId }),
+    });
+    return connectionId;
+  }
+
+  update(
+    connectionId: string,
+    userId: string,
+    sequence: number,
+    cardKey: string | null,
+    mode: PresenceEntry['mode'],
+  ): boolean {
+    const connection = this.connections.get(connectionId);
+    if (!connection || connection.retired || connection.user.id !== userId) {
+      return false;
+    }
+    // Monotonic per connection, so a delayed request cannot undo a newer one.
+    if (sequence <= connection.sequence) return true;
+    // Coerced rather than rejected: a fake editing warning deters others from editing.
+    if (!connection.capabilities.canDeclareEditing) mode = 'viewing';
+    if (connection.cardKey === cardKey && connection.mode === mode) {
+      connection.sequence = sequence;
+      connection.expiresAt = Date.now() + LEASE_MS;
+      return true;
+    }
+    this.applyMove(connection, sequence, cardKey, mode, Date.now());
+    return true;
+  }
+
+  private applyMove(
+    connection: Connection,
+    sequence: number,
+    cardKey: string | null,
+    mode: PresenceEntry['mode'],
+    now: number,
+  ): void {
+    const previous = connection.cardKey;
+    if (previous !== cardKey) connection.lastSent = null;
+    Object.assign(connection, {
+      sequence,
+      cardKey,
+      mode,
+      expiresAt: now + LEASE_MS,
+    });
+    if (previous) this.presenceUpdated(previous);
+    if (cardKey && cardKey !== previous) this.presenceUpdated(cardKey);
+  }
+
+  disconnect(connectionId: string): void {
+    const connection = this.connections.get(connectionId);
+    if (!connection) return;
+    this.connections.delete(connectionId);
+    this.closeQuietly(connection);
+    if (connection.cardKey) this.presenceUpdated(connection.cardKey);
+  }
+
+  // `users()` dedups by user id, so a retiring connection's entry can outlive
+  // its socket without observers seeing a change.
+  retire(connectionId: string): void {
+    const connection = this.connections.get(connectionId);
+    if (!connection) return;
+    connection.retired = true;
+    // The entry only has to bridge the client's reconnect. Left on its full
+    // lease it would go on reporting the card and mode held at retirement,
+    // and `editing` wins in users(), so it would mask the live entry the
+    // replacement declares.
+    connection.expiresAt = Math.min(
+      connection.expiresAt,
+      Date.now() + RETIRED_LEASE_MS,
+    );
+  }
+
+  // Only card changes go on the wire; a removed card is announced as updated.
+  private changed(event: ChangeEvent): void {
+    const cardKeys = event.changes.flatMap((change) =>
+      change.kind === 'card.updated' || change.kind === 'card.removed'
+        ? [change.key]
+        : [],
+    );
+    if (cardKeys.length > 0) this.cardsUpdated(cardKeys, event.actor);
+  }
+
+  cardsUpdated(cardKeys: string[], actor: ActorRef): void {
+    for (const cardKey of new Set(cardKeys)) {
+      const withIdentity = this.encode('card.updated', {
+        cardKey,
+        userId: actor.id,
+        userName: actor.name,
+      });
+      const withoutIdentity = this.encode('card.updated', { cardKey });
+      // Project-wide, since a page can show fields of cards it is not on.
+      for (const [connectionId, connection] of [...this.connections]) {
+        this.deliver(
+          connectionId,
+          connection.capabilities.canSeeIdentity
+            ? withIdentity
+            : withoutIdentity,
+        );
+      }
+    }
+  }
+
+  dispose(): void {
+    this.unsubscribe();
+    clearInterval(this.expiryTimer);
+    const connections = [...this.connections.values()];
+    this.connections.clear();
+    for (const connection of connections) {
+      this.closeQuietly(connection);
+    }
+  }
+
+  private users(cardKey: string): PresenceEntry[] {
+    const users = new Map<string, PresenceEntry>();
+    for (const { user, cardKey: key, mode } of this.connections.values()) {
+      if (key !== cardKey) continue;
+      if (!users.has(user.id) || mode === 'editing') {
+        users.set(user.id, { userId: user.id, userName: user.name, mode });
+      }
+    }
+    // Sorted so identical occupancy always serializes the same way, which
+    // the per-recipient dedup in presenceUpdated() depends on.
+    return [...users.values()].sort((a, b) => a.userId.localeCompare(b.userId));
+  }
+
+  private presenceUpdated(cardKey: string): void {
+    const users = this.users(cardKey);
+    const serialized = JSON.stringify(users);
+    const message = this.encode('presence.updated', { cardKey, users });
+    for (const [connectionId, connection] of this.onCard(cardKey)) {
+      // Presence exists to keep editors from colliding, so a reader has no use
+      // for it and is not told who else is here. Readers still declare their
+      // own presence, which is why users() keeps them: editors see readers.
+      if (!connection.capabilities.canSeePresence) continue;
+      if (connection.lastSent === serialized) continue;
+      this.deliver(connectionId, message);
+      connection.lastSent = serialized;
+    }
+  }
+
+  // Presence is delivered per card.
+  private onCard(cardKey: string): [string, Connection][] {
+    return [...this.connections].filter(([, c]) => c.cardKey === cardKey);
+  }
+
+  private encode(event: string, data: unknown): SSEMessage {
+    return { event, data: JSON.stringify(data) };
+  }
+
+  private deliver(connectionId: string, message: SSEMessage): void {
+    const connection = this.connections.get(connectionId);
+    // onCard() still yields a retired connection: it keeps its cardKey so the
+    // occupant list does not change while its replacement connects.
+    if (!connection || connection.retired) return;
+    try {
+      connection.delivery.send(message);
+    } catch {
+      this.disconnect(connectionId);
+    }
+  }
+
+  private expire(): void {
+    for (const [connectionId, connection] of this.connections) {
+      if (connection.expiresAt > Date.now()) continue;
+      if (!connection.retired && !connection.cardKey) continue;
+      const cardKey = connection.cardKey;
+      if (connection.retired) this.connections.delete(connectionId);
+      else connection.cardKey = null;
+      if (cardKey) this.presenceUpdated(cardKey);
+    }
+  }
+
+  private closeQuietly(connection: Connection): void {
+    if (connection.retired) return;
+    try {
+      connection.delivery.close();
+    } catch {
+      /* already closed */
+    }
+  }
+}

package/src/domain/events/schema.ts

@@ -0,0 +1,11 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { z } from 'zod';
+
+export const presenceSchema = z.object({
+  connectionId: z.uuid(),
+  sequence: z.number().int().nonnegative(),
+  cardKey: z.string().min(1).nullable(),
+  mode: z.enum(['viewing', 'editing']),
+});

package/src/domain/fieldTypes/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as fieldTypeService from './service.js';
@@ -35,10 +25,10 @@ const router = new Hono();
  *         description: project_path not set or other internal error
  */
 router.get('/', requireRole(UserRole.Reader), async (c) => {
-  const commands = c.get('commands');
+  const ws = c.get('ws');
 
   try {
-    const fieldTypes = await fieldTypeService.getFieldTypes(commands);
+    const fieldTypes = await fieldTypeService.getFieldTypes(ws);
     return c.json(fieldTypes);
   } catch (error) {
     return c.json(
@@ -84,11 +74,11 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', createFieldTypeSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { identifier, dataType } = c.req.valid('json');
 
     try {
-      await fieldTypeService.createFieldType(commands, identifier, dataType);
+      await fieldTypeService.createFieldType(ws, identifier, dataType);
       return c.json({ message: 'Field type created successfully' });
     } catch (error) {
       return c.json(

package/src/domain/fieldTypes/schema.ts

@@ -1,15 +1,6 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import { z } from 'zod';
 import { identifierSchema } from '../../common/validationSchemas.js';
 

package/src/domain/fieldTypes/service.ts

@@ -1,38 +1,26 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
-import type { DataType } from '@cyberismo/data-handler/interfaces/resource-interfaces';
+import type { Workspace } from '@cyberismo/data-handler';
+import type { DataType } from '@cyberismo/model';
 
-export async function getFieldTypes(commands: CommandManager) {
-  const response = await commands.showCmd.showResources('fieldTypes');
+export async function getFieldTypes(ws: Workspace) {
+  const response = await ws.resources.list('fieldTypes');
   if (!response) {
     throw new Error('No field types found');
   }
 
   const fieldTypes = await Promise.all(
-    response.map((fieldType: string) =>
-      commands.showCmd.showResource(fieldType),
-    ),
+    response.map((fieldType: string) => ws.resources.show(fieldType)),
   );
 
   return fieldTypes;
 }
 
 export async function createFieldType(
-  commands: CommandManager,
+  ws: Workspace,
   identifier: string,
   dataType: DataType,
 ) {
-  await commands.createCmd.createFieldType(identifier, dataType);
+  await ws.resources.create(identifier, 'fieldTypes', { dataType });
 }

package/src/domain/graphModels/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as graphModelService from './service.js';
@@ -50,10 +40,10 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', createGraphModelSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { identifier } = c.req.valid('json');
 
-    await graphModelService.createGraphModel(commands, identifier);
+    await graphModelService.createGraphModel(ws, identifier);
     return c.json({ message: 'Graph model created successfully' });
   },
 );

package/src/domain/graphModels/schema.ts

@@ -1,15 +1,6 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import { z } from 'zod';
 import { identifierSchema } from '../../common/validationSchemas.js';
 

package/src/domain/graphModels/service.ts

@@ -1,21 +1,8 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
+import type { Workspace } from '@cyberismo/data-handler';
 
-export async function createGraphModel(
-  commands: CommandManager,
-  graphModelName: string,
-) {
-  await commands.createCmd.createGraphModel(graphModelName);
+export async function createGraphModel(ws: Workspace, graphModelName: string) {
+  await ws.resources.create(graphModelName, 'graphModels', {});
 }

package/src/domain/graphViews/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as graphViewService from './service.js';
@@ -50,9 +40,9 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', createGraphViewSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { identifier } = c.req.valid('json');
-    await graphViewService.createGraphView(commands, identifier);
+    await graphViewService.createGraphView(ws, identifier);
     return c.json({ message: 'Graph view created successfully' });
   },
 );

package/src/domain/graphViews/schema.ts

@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
+
 import { z } from 'zod';
 import { identifierSchema } from '../../common/validationSchemas.js';
 

package/src/domain/graphViews/service.ts

@@ -1,20 +1,7 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
-export async function createGraphView(
-  commands: CommandManager,
-  graphViewName: string,
-) {
-  await commands.createCmd.createGraphView(graphViewName);
+import type { Workspace } from '@cyberismo/data-handler';
+export async function createGraphView(ws: Workspace, graphViewName: string) {
+  await ws.resources.create(graphViewName, 'graphViews', {});
 }

package/src/domain/labels/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as labelsService from './service.js';
@@ -31,8 +21,8 @@ const router = new Hono();
  */
 
 router.get('/', requireRole(UserRole.Reader), async (c) => {
-  const commands = c.get('commands');
-  const labels = await labelsService.getLabels(commands);
+  const ws = c.get('ws');
+  const labels = await labelsService.getLabels(ws);
   return c.json(labels);
 });
 

package/src/domain/labels/service.ts

@@ -1,23 +1,13 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
-import type { CommandManager } from '@cyberismo/data-handler';
+import type { Workspace } from '@cyberismo/data-handler';
 
 /**
  * Returns all unique labels available in the project.
- * @param commands command manager used for the query
+ * @param ws command manager used for the query
  * @returns a list of labels
  */
-export async function getLabels(commands: CommandManager): Promise<string[]> {
-  return (await commands.showCmd.showLabels()).sort();
+export async function getLabels(ws: Workspace): Promise<string[]> {
+  return (await ws.cards.labels()).sort();
 }

package/src/domain/linkTypes/index.ts

@@ -1,15 +1,5 @@
-/**
-  Cyberismo
-  Copyright © Cyberismo Ltd and contributors 2025
-  This program is free software: you can redistribute it and/or modify it under
-  the terms of the GNU Affero General Public License version 3 as published by
-  the Free Software Foundation.
-  This program is distributed in the hope that it will be useful, but WITHOUT
-  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-  FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
-  details. You should have received a copy of the GNU Affero General Public
-  License along with this program. If not, see <https://www.gnu.org/licenses/>.
-*/
+// SPDX-FileCopyrightText: Cyberismo Ltd and contributors
+// SPDX-License-Identifier: AGPL-3.0-only
 
 import { Hono } from 'hono';
 import * as linkTypeService from './service.js';
@@ -35,10 +25,10 @@ const router = new Hono();
  *         description: project_path not set or other internal error
  */
 router.get('/', requireRole(UserRole.Reader), async (c) => {
-  const commands = c.get('commands');
+  const ws = c.get('ws');
 
   try {
-    const linkTypes = await linkTypeService.getLinkTypes(commands);
+    const linkTypes = await linkTypeService.getLinkTypes(ws);
     return c.json(linkTypes);
   } catch (error) {
     return c.json(
@@ -80,10 +70,10 @@ router.post(
   requireRole(UserRole.Admin),
   zValidator('json', createLinkTypeSchema),
   async (c) => {
-    const commands = c.get('commands');
+    const ws = c.get('ws');
     const { identifier } = c.req.valid('json');
 
-    await linkTypeService.createLinkType(commands, identifier);
+    await linkTypeService.createLinkType(ws, identifier);
     return c.json({ message: 'Link type created successfully' });
   },
 );