@velocelab/message 0.1.2 → 0.1.3

package/dist/index.d.ts

@@ -66,7 +66,8 @@ declare module "yumeri" {
 export declare class MessageService extends Service {
     private readonly typesById;
     private readonly db;
-    private readonly notification;
+    private readonly context;
+    private readonly core;
     constructor(ctx: Context);
     registerType(owner: Context, type: MessageType): void;
     types(): MessageType[];

package/dist/index.js

@@ -12,8 +12,9 @@ const record = (row) => ({ id: Number(row.id), userId: row.user_id, type: row.ty
 export class MessageService extends Service {
     typesById;
     db;
-    notification;
-    constructor(ctx) { super(ctx); const core = ctx.getCore(); this.typesById = registries.get(core) ?? new Map(); registries.set(core, this.typesById); this.db = ctx.component.database; this.notification = ctx.component.notification; }
+    context;
+    core;
+    constructor(ctx) { super(ctx); this.context = ctx; const core = ctx.getCore(); this.core = core; this.typesById = registries.get(core) ?? new Map(); registries.set(core, this.typesById); this.db = ctx.component.database; }
     registerType(owner, type) { if (this.typesById.has(type.id))
         throw new Error(`Message type already registered: ${type.id}`); this.typesById.set(type.id, type); owner.affect(() => { if (this.typesById.get(type.id) === type)
         this.typesById.delete(type.id); }); }
@@ -31,7 +32,8 @@ export class MessageService extends Service {
         result = record({ ...existing, ...data, type: type.id });
     }
     else
-        result = record(await this.db.create("messages", { ...key, ...data, created_at: now })); await this.notification.send({ userId: input.userId, title: input.title, body: input.subtitle, tag: `message-${type.id}-${input.dedupeKey}`, url: input.action?.href }); return result; }
+        result = record(await this.db.create("messages", { ...key, ...data, created_at: now })); const notification = this.context.component.notification ?? this.core.getService("notification", this.context); if (notification)
+        await notification.send({ userId: input.userId, title: input.title, body: input.subtitle, tag: `message-${type.id}-${input.dedupeKey}`, url: input.action?.href }); return result; }
     async remove(userId, id) { await this.db.remove("messages", { id, user_id: userId }); }
     async markRead(userId, id) { await this.db.update("messages", { id, user_id: userId }, { read: true, updated_at: new Date().toISOString() }); }
     async list(userId) { return (await this.db.select("messages", { user_id: userId })).sort((a, b) => String(b.updated_at).localeCompare(String(a.updated_at))).map(record); }

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@velocelab/message",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "main": "dist/index.js",
   "dev": "src/index.ts",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "../../node_modules/.bin/tsc -p tsconfig.json && ../../node_modules/.bin/vite build"
+    "build": "../../node_modules/.bin/tsc -p tsconfig.json && ../../node_modules/.bin/vite build",
+    "test": "node --test tests/*.test.mjs"
   },
   "dependencies": {
     "@velocelab/dashboard": "^0.1.5",

package/src/index.ts

@@ -23,13 +23,14 @@ const record = (row: StoredMessage): MessageRecord => ({ id: Number(row.id), use
 export class MessageService extends Service {
   private readonly typesById: Map<string, MessageType>;
   private readonly db: Database;
-  private readonly notification: NotificationService;
-  constructor(ctx: Context) { super(ctx); const core = ctx.getCore(); this.typesById = registries.get(core) ?? new Map(); registries.set(core, this.typesById); this.db = ctx.component.database as Database; this.notification = ctx.component.notification as NotificationService; }
+  private readonly context: Context;
+  private readonly core: Core;
+  constructor(ctx: Context) { super(ctx); this.context = ctx; const core = ctx.getCore(); this.core = core; this.typesById = registries.get(core) ?? new Map(); registries.set(core, this.typesById); this.db = ctx.component.database as Database; }
   registerType(owner: Context, type: MessageType) { if (this.typesById.has(type.id)) throw new Error(`Message type already registered: ${type.id}`); this.typesById.set(type.id, type); owner.affect(() => { if (this.typesById.get(type.id) === type) this.typesById.delete(type.id); }); }
   types() { return [...this.typesById.values()]; }
   async preferences(userId: number) { return await this.db.select("message_preferences", { user_id: userId }); }
   async setEnabled(userId: number, plugin: string, type: string, enabled: boolean) { if (!this.types().some(item => item.plugin === plugin && (!type || item.id === type))) throw Error("Unknown message type"); const key = { user_id: userId, plugin, type }; const existing = await this.db.selectOne("message_preferences", key); if (existing) await this.db.update("message_preferences", key, { enabled }); else await this.db.create("message_preferences", { ...key, enabled }); }
-  async send(input: MessageInput): Promise<MessageRecord | undefined> { const type = this.typesById.get(input.type); if (!type) throw Error(`Message type is not registered: ${input.type}`); const prefs = await this.preferences(input.userId); if (prefs.some(item => item.plugin === type.plugin && !item.enabled && (!item.type || item.type === type.id))) return; const now = new Date().toISOString(); const action = input.action ? JSON.stringify(input.action) : ""; const key = { user_id: input.userId, type: type.id, dedupe_key: `${type.id}:${input.dedupeKey}` }; const data = { icon: input.icon || "bell", title: input.title, subtitle: input.subtitle || "", action, source: type.plugin, read: false, updated_at: now }; const existing = await this.db.selectOne("messages", key); let result: MessageRecord; if (existing) { await this.db.update("messages", { id: existing.id }, data); result = record({ ...existing, ...data, type: type.id }); } else result = record(await this.db.create("messages", { ...key, ...data, created_at: now })); await this.notification.send({ userId: input.userId, title: input.title, body: input.subtitle, tag: `message-${type.id}-${input.dedupeKey}`, url: input.action?.href }); return result; }
+  async send(input: MessageInput): Promise<MessageRecord | undefined> { const type = this.typesById.get(input.type); if (!type) throw Error(`Message type is not registered: ${input.type}`); const prefs = await this.preferences(input.userId); if (prefs.some(item => item.plugin === type.plugin && !item.enabled && (!item.type || item.type === type.id))) return; const now = new Date().toISOString(); const action = input.action ? JSON.stringify(input.action) : ""; const key = { user_id: input.userId, type: type.id, dedupe_key: `${type.id}:${input.dedupeKey}` }; const data = { icon: input.icon || "bell", title: input.title, subtitle: input.subtitle || "", action, source: type.plugin, read: false, updated_at: now }; const existing = await this.db.selectOne("messages", key); let result: MessageRecord; if (existing) { await this.db.update("messages", { id: existing.id }, data); result = record({ ...existing, ...data, type: type.id }); } else result = record(await this.db.create("messages", { ...key, ...data, created_at: now })); const notification = (this.context.component.notification as NotificationService | undefined) ?? this.core.getService("notification", this.context) as NotificationService | undefined; if (notification) await notification.send({ userId: input.userId, title: input.title, body: input.subtitle, tag: `message-${type.id}-${input.dedupeKey}`, url: input.action?.href }); return result; }
   async remove(userId: number, id: number) { await this.db.remove("messages", { id, user_id: userId }); }
   async markRead(userId: number, id: number) { await this.db.update("messages", { id, user_id: userId }, { read: true, updated_at: new Date().toISOString() }); }
   async list(userId: number) { return (await this.db.select("messages", { user_id: userId })).sort((a, b) => String(b.updated_at).localeCompare(String(a.updated_at))).map(record); }

package/tests/service.test.mjs

@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { MessageService } from "../dist/index.js";
+
+function setup({ coreNotification = true, injectedNotification = false } = {}) {
+  const persisted = [];
+  const notifications = [];
+  const db = {
+    async select() { return []; },
+    async selectOne() { return undefined; },
+    async create(_table, value) { const row = { ...value, id: persisted.length + 1 }; persisted.push(row); return row; },
+  };
+  class NotificationService {
+    async send(input) { notifications.push(input); }
+  }
+  const core = {
+    services: coreNotification ? { notification: NotificationService } : {},
+    getService(name, context) { const ServiceType = this.services[name]; return ServiceType ? new ServiceType(context) : undefined; },
+  };
+  const context = {
+    component: { database: db, ...(injectedNotification ? { notification: new NotificationService() } : {}) },
+    getCore() { return core; },
+  };
+  const service = new MessageService(context);
+  service.registerType({ affect() {} }, { id: "test:message", plugin: "test", label: "Test" });
+  return { notifications, persisted, service };
+}
+
+test("resolves notification service from Core when caller context does not inject it", async () => {
+  const f = setup();
+  const result = await f.service.send({ userId: 4, type: "test:message", dedupeKey: "one", title: "Update" });
+  assert.equal(result?.title, "Update");
+  assert.equal(f.persisted.length, 1);
+  assert.equal(f.notifications.length, 1);
+});
+
+test("persists message when notification service is not registered", async () => {
+  const f = setup({ coreNotification: false });
+  const result = await f.service.send({ userId: 4, type: "test:message", dedupeKey: "one", title: "Update" });
+  assert.equal(result?.title, "Update");
+  assert.equal(f.persisted.length, 1);
+  assert.equal(f.notifications.length, 0);
+});