@unifiedcommerce/plugin-notifications 0.0.1

package/src/services/notification-service.ts

@@ -0,0 +1,270 @@
+import { eq, and } from "drizzle-orm";
+import { notificationTemplates, customerNotificationPrefs, notificationLog } from "../schema";
+import type {
+  Db, NotificationTemplate, NotificationLogEntry, Channel, NotificationStatus,
+  Result,
+} from "../types";
+import { Ok, Err } from "../types";
+import type { SMSAdapter, PushAdapter, NotificationAdapters } from "../adapters/types";
+
+export class NotificationService {
+  private smsAdapter: SMSAdapter | undefined;
+  private pushAdapter: PushAdapter | undefined;
+
+  constructor(private db: Db, adapters?: NotificationAdapters) {
+    this.smsAdapter = adapters?.sms;
+    this.pushAdapter = adapters?.push;
+  }
+
+  // ── Template CRUD ──────────────────────────────────────────────────
+
+  async createTemplate(orgId: string, input: {
+    event: string; channel: Channel; subject?: string; bodyTemplate: string;
+  }): Promise<Result<NotificationTemplate>> {
+    const existing = await this.db.select().from(notificationTemplates)
+      .where(and(
+        eq(notificationTemplates.organizationId, orgId),
+        eq(notificationTemplates.event, input.event),
+        eq(notificationTemplates.channel, input.channel),
+      ));
+    if (existing.length > 0) return Err(`Template for '${input.event}' on '${input.channel}' already exists`);
+    const rows = await this.db.insert(notificationTemplates).values({
+      organizationId: orgId,
+      event: input.event,
+      channel: input.channel,
+      subject: input.subject,
+      bodyTemplate: input.bodyTemplate,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  async listTemplates(orgId: string, filters?: {
+    event?: string; channel?: Channel;
+  }): Promise<Result<NotificationTemplate[]>> {
+    const conditions = [eq(notificationTemplates.organizationId, orgId)];
+    if (filters?.event) conditions.push(eq(notificationTemplates.event, filters.event));
+    if (filters?.channel) conditions.push(eq(notificationTemplates.channel, filters.channel));
+    const rows = await this.db.select().from(notificationTemplates).where(and(...conditions));
+    return Ok(rows);
+  }
+
+  async getTemplate(orgId: string, id: string): Promise<Result<NotificationTemplate>> {
+    const rows = await this.db.select().from(notificationTemplates)
+      .where(and(eq(notificationTemplates.organizationId, orgId), eq(notificationTemplates.id, id)));
+    if (rows.length === 0) return Err("Template not found");
+    return Ok(rows[0]!);
+  }
+
+  async updateTemplate(orgId: string, id: string, input: {
+    subject?: string; bodyTemplate?: string; isActive?: boolean;
+  }): Promise<Result<NotificationTemplate>> {
+    const existing = await this.db.select().from(notificationTemplates)
+      .where(and(eq(notificationTemplates.organizationId, orgId), eq(notificationTemplates.id, id)));
+    if (existing.length === 0) return Err("Template not found");
+    const rows = await this.db.update(notificationTemplates).set({
+      ...(input.subject !== undefined ? { subject: input.subject } : {}),
+      ...(input.bodyTemplate !== undefined ? { bodyTemplate: input.bodyTemplate } : {}),
+      ...(input.isActive !== undefined ? { isActive: input.isActive } : {}),
+      updatedAt: new Date(),
+    }).where(eq(notificationTemplates.id, id)).returning();
+    return Ok(rows[0]!);
+  }
+
+  async deleteTemplate(orgId: string, id: string): Promise<Result<NotificationTemplate>> {
+    const existing = await this.db.select().from(notificationTemplates)
+      .where(and(eq(notificationTemplates.organizationId, orgId), eq(notificationTemplates.id, id)));
+    if (existing.length === 0) return Err("Template not found");
+    const rows = await this.db.update(notificationTemplates).set({
+      isActive: false,
+      updatedAt: new Date(),
+    }).where(eq(notificationTemplates.id, id)).returning();
+    return Ok(rows[0]!);
+  }
+
+  // ── Template Rendering ─────────────────────────────────────────────
+
+  /**
+   * Simple Handlebars-style template rendering.
+   * Replaces {{key}} with values from the data object.
+   * Supports nested keys via dot notation: {{order.id}}.
+   */
+  renderTemplate(template: string, data: Record<string, unknown>): string {
+    return template.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (_match, key: string) => {
+      const parts = key.split(".");
+      let value: unknown = data;
+      for (const part of parts) {
+        if (value == null || typeof value !== "object") return "";
+        value = (value as Record<string, unknown>)[part];
+      }
+      return value != null ? String(value) : "";
+    });
+  }
+
+  // ── Send Notification ──────────────────────────────────────────────
+
+  /**
+   * Unified send: resolves template, checks customer preferences,
+   * dispatches to the correct channel adapter, and logs the result.
+   */
+  async send(orgId: string, input: {
+    event: string;
+    recipient: string;
+    channel: Channel;
+    customerId?: string;
+    data?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+  }): Promise<Result<NotificationLogEntry>> {
+    // Check customer preference if customerId is provided and channel is not "print"
+    if (input.customerId && input.channel !== "print") {
+      const prefChannel = input.channel as "email" | "sms" | "push";
+      const prefs = await this.db.select().from(customerNotificationPrefs)
+        .where(and(
+          eq(customerNotificationPrefs.organizationId, orgId),
+          eq(customerNotificationPrefs.customerId, input.customerId),
+          eq(customerNotificationPrefs.channel, prefChannel),
+        ));
+      if (prefs.length > 0 && !prefs[0]!.isEnabled) {
+        return Err(`Customer has disabled ${input.channel} notifications`);
+      }
+    }
+
+    // Resolve template if one exists for this event+channel
+    let body = "";
+    let subject: string | undefined;
+    const templates = await this.db.select().from(notificationTemplates)
+      .where(and(
+        eq(notificationTemplates.organizationId, orgId),
+        eq(notificationTemplates.event, input.event),
+        eq(notificationTemplates.channel, input.channel),
+        eq(notificationTemplates.isActive, true),
+      ));
+
+    if (templates.length > 0) {
+      const tmpl = templates[0]!;
+      body = this.renderTemplate(tmpl.bodyTemplate, input.data ?? {});
+      if (tmpl.subject) {
+        subject = this.renderTemplate(tmpl.subject, input.data ?? {});
+      }
+    }
+
+    // Dispatch to adapter
+    let adapterError: string | undefined;
+    let adapterMessageId: string | undefined;
+
+    if (input.channel === "sms" && this.smsAdapter) {
+      const result = await this.smsAdapter.send({ to: input.recipient, body });
+      if (!result.ok) {
+        adapterError = result.error;
+      } else {
+        adapterMessageId = result.value.messageId;
+      }
+    } else if (input.channel === "push" && this.pushAdapter) {
+      const result = await this.pushAdapter.send({
+        deviceToken: input.recipient,
+        title: subject ?? input.event,
+        body,
+        ...(input.data != null ? { data: input.data } : {}),
+      });
+      if (!result.ok) {
+        adapterError = result.error;
+      } else {
+        adapterMessageId = result.value.messageId;
+      }
+    }
+
+    // Log the result
+    const status: NotificationStatus = adapterError ? "failed" : "sent";
+    const logRows = await this.db.insert(notificationLog).values({
+      organizationId: orgId,
+      channel: input.channel,
+      event: input.event,
+      recipient: input.recipient,
+      status,
+      error: adapterError,
+      metadata: {
+        ...input.metadata,
+        ...(adapterMessageId ? { adapterMessageId } : {}),
+        ...(input.data ? { templateData: input.data } : {}),
+      },
+    }).returning();
+
+    return Ok(logRows[0]!);
+  }
+
+  // ── Direct Channel Sends ───────────────────────────────────────────
+
+  async sendSMS(orgId: string, to: string, body: string): Promise<Result<NotificationLogEntry>> {
+    let adapterError: string | undefined;
+    let adapterMessageId: string | undefined;
+
+    if (this.smsAdapter) {
+      const result = await this.smsAdapter.send({ to, body });
+      if (!result.ok) {
+        adapterError = result.error;
+      } else {
+        adapterMessageId = result.value.messageId;
+      }
+    }
+
+    const status: NotificationStatus = adapterError ? "failed" : "sent";
+    const rows = await this.db.insert(notificationLog).values({
+      organizationId: orgId,
+      channel: "sms",
+      event: "direct.sms",
+      recipient: to,
+      status,
+      error: adapterError,
+      metadata: adapterMessageId ? { adapterMessageId } : {},
+    }).returning();
+
+    return Ok(rows[0]!);
+  }
+
+  async sendPush(
+    orgId: string,
+    deviceToken: string,
+    title: string,
+    body: string,
+    data?: Record<string, unknown>,
+  ): Promise<Result<NotificationLogEntry>> {
+    let adapterError: string | undefined;
+    let adapterMessageId: string | undefined;
+
+    if (this.pushAdapter) {
+      const result = await this.pushAdapter.send({ deviceToken, title, body, ...(data != null ? { data } : {}) });
+      if (!result.ok) {
+        adapterError = result.error;
+      } else {
+        adapterMessageId = result.value.messageId;
+      }
+    }
+
+    const status: NotificationStatus = adapterError ? "failed" : "sent";
+    const rows = await this.db.insert(notificationLog).values({
+      organizationId: orgId,
+      channel: "push",
+      event: "direct.push",
+      recipient: deviceToken,
+      status,
+      error: adapterError,
+      metadata: adapterMessageId ? { adapterMessageId } : {},
+    }).returning();
+
+    return Ok(rows[0]!);
+  }
+
+  // ── Log Queries ────────────────────────────────────────────────────
+
+  async listLog(orgId: string, filters?: {
+    channel?: string; event?: string; status?: NotificationStatus; limit?: number;
+  }): Promise<Result<NotificationLogEntry[]>> {
+    const conditions = [eq(notificationLog.organizationId, orgId)];
+    if (filters?.channel) conditions.push(eq(notificationLog.channel, filters.channel));
+    if (filters?.event) conditions.push(eq(notificationLog.event, filters.event));
+    if (filters?.status) conditions.push(eq(notificationLog.status, filters.status));
+    let query = this.db.select().from(notificationLog).where(and(...conditions)).$dynamic();
+    if (filters?.limit) query = query.limit(filters.limit);
+    const rows = await query;
+    return Ok(rows);
+  }
+}

package/src/services/preference-service.ts

@@ -0,0 +1,92 @@
+import { eq, and } from "drizzle-orm";
+import { customerNotificationPrefs, notificationTemplates } from "../schema";
+import type { Db, CustomerNotificationPref, PrefChannel, Result } from "../types";
+import { Ok } from "../types";
+
+export class PreferenceService {
+  constructor(private db: Db) {}
+
+  /**
+   * Upsert a customer notification preference for a specific channel.
+   * If a preference already exists for this org+customer+channel, it is updated.
+   */
+  async setPreference(orgId: string, customerId: string, channel: PrefChannel, isEnabled: boolean, destination?: string): Promise<Result<CustomerNotificationPref>> {
+    const existing = await this.db.select().from(customerNotificationPrefs)
+      .where(and(
+        eq(customerNotificationPrefs.organizationId, orgId),
+        eq(customerNotificationPrefs.customerId, customerId),
+        eq(customerNotificationPrefs.channel, channel),
+      ));
+
+    if (existing.length > 0) {
+      const rows = await this.db.update(customerNotificationPrefs).set({
+        isEnabled,
+        ...(destination !== undefined ? { destination } : {}),
+        updatedAt: new Date(),
+      }).where(eq(customerNotificationPrefs.id, existing[0]!.id)).returning();
+      return Ok(rows[0]!);
+    }
+
+    const rows = await this.db.insert(customerNotificationPrefs).values({
+      organizationId: orgId,
+      customerId,
+      channel,
+      isEnabled,
+      destination,
+    }).returning();
+    return Ok(rows[0]!);
+  }
+
+  /** Get all notification preferences for a customer. */
+  async getPreferences(orgId: string, customerId: string): Promise<Result<CustomerNotificationPref[]>> {
+    const rows = await this.db.select().from(customerNotificationPrefs)
+      .where(and(
+        eq(customerNotificationPrefs.organizationId, orgId),
+        eq(customerNotificationPrefs.customerId, customerId),
+      ));
+    return Ok(rows);
+  }
+
+  /**
+   * Determine which channels should fire for a given customer+event.
+   *
+   * Logic:
+   * 1. Find all active templates for the event.
+   * 2. For each template channel (email/sms/push), check customer preferences.
+   * 3. If no preference exists, the channel is considered enabled (opt-out model).
+   * 4. Returns channels that have an active template AND are not disabled by the customer.
+   */
+  async getActiveChannels(orgId: string, customerId: string, event: string): Promise<Result<PrefChannel[]>> {
+    // Find active templates for this event (email, sms, push only — not print)
+    const templates = await this.db.select().from(notificationTemplates)
+      .where(and(
+        eq(notificationTemplates.organizationId, orgId),
+        eq(notificationTemplates.event, event),
+        eq(notificationTemplates.isActive, true),
+      ));
+
+    const templateChannels = templates
+      .map((t) => t.channel)
+      .filter((ch): ch is PrefChannel => ch === "email" || ch === "sms" || ch === "push");
+
+    if (templateChannels.length === 0) return Ok([]);
+
+    // Get customer preferences
+    const prefs = await this.db.select().from(customerNotificationPrefs)
+      .where(and(
+        eq(customerNotificationPrefs.organizationId, orgId),
+        eq(customerNotificationPrefs.customerId, customerId),
+      ));
+
+    const prefMap = new Map(prefs.map((p) => [p.channel, p.isEnabled]));
+
+    // Filter: include channel if no preference (opt-out model) or explicitly enabled
+    const active = templateChannels.filter((ch) => {
+      const enabled = prefMap.get(ch);
+      return enabled !== false; // undefined (no pref) → allowed; true → allowed; false → blocked
+    });
+
+    // Deduplicate
+    return Ok([...new Set(active)]);
+  }
+}

package/src/services/print-service.ts

@@ -0,0 +1,99 @@
+import { eq, and } from "drizzle-orm";
+import { printJobs } from "../schema";
+import type { Db, PrintJob, PrintJobStatus, PrintJobType, Result } from "../types";
+import { Ok, Err } from "../types";
+import type { PrintAdapter } from "../adapters/types";
+
+export class PrintService {
+  constructor(private db: Db, private adapter?: PrintAdapter) {}
+
+  /** Submit a new print job. Dispatches to the print adapter if configured. */
+  async submitJob(orgId: string, input: {
+    type: PrintJobType;
+    printerId: string;
+    content: Record<string, unknown>;
+    format?: "esc_pos" | "star_line" | "label";
+  }): Promise<Result<PrintJob>> {
+    const rows = await this.db.insert(printJobs).values({
+      organizationId: orgId,
+      type: input.type,
+      printerId: input.printerId,
+      content: input.content,
+    }).returning();
+    const job = rows[0]!;
+
+    // Dispatch to adapter if available
+    if (this.adapter) {
+      const result = await this.adapter.print({
+        printerId: input.printerId,
+        content: input.content,
+        format: input.format ?? "esc_pos",
+      });
+      if (!result.ok) {
+        // Mark as failed
+        const updated = await this.db.update(printJobs).set({
+          status: "failed" as const,
+          error: result.error,
+          updatedAt: new Date(),
+        }).where(eq(printJobs.id, job.id)).returning();
+        return Ok(updated[0]!);
+      }
+    }
+
+    return Ok(job);
+  }
+
+  /** Get a single print job by ID. */
+  async getJob(orgId: string, id: string): Promise<Result<PrintJob>> {
+    const rows = await this.db.select().from(printJobs)
+      .where(and(eq(printJobs.organizationId, orgId), eq(printJobs.id, id)));
+    if (rows.length === 0) return Err("Print job not found");
+    return Ok(rows[0]!);
+  }
+
+  /** List print jobs with optional filters. */
+  async listJobs(orgId: string, filters?: {
+    status?: PrintJobStatus; printerId?: string; type?: PrintJobType; limit?: number;
+  }): Promise<Result<PrintJob[]>> {
+    const conditions = [eq(printJobs.organizationId, orgId)];
+    if (filters?.status) conditions.push(eq(printJobs.status, filters.status));
+    if (filters?.printerId) conditions.push(eq(printJobs.printerId, filters.printerId));
+    if (filters?.type) conditions.push(eq(printJobs.type, filters.type));
+    let query = this.db.select().from(printJobs).where(and(...conditions)).$dynamic();
+    if (filters?.limit) query = query.limit(filters.limit);
+    const rows = await query;
+    return Ok(rows);
+  }
+
+  /**
+   * Update the status of a print job.
+   * Valid transitions:
+   *   queued → printing → printed
+   *   queued → failed
+   *   printing → failed
+   */
+  async updateJobStatus(orgId: string, id: string, status: PrintJobStatus, error?: string): Promise<Result<PrintJob>> {
+    const existing = await this.db.select().from(printJobs)
+      .where(and(eq(printJobs.organizationId, orgId), eq(printJobs.id, id)));
+    if (existing.length === 0) return Err("Print job not found");
+
+    const current = existing[0]!.status;
+    const validTransitions: Record<string, string[]> = {
+      queued: ["printing", "failed"],
+      printing: ["printed", "failed"],
+      printed: [],
+      failed: [],
+    };
+
+    if (!validTransitions[current]?.includes(status)) {
+      return Err(`Cannot transition from '${current}' to '${status}'`);
+    }
+
+    const rows = await this.db.update(printJobs).set({
+      status,
+      ...(error !== undefined ? { error } : {}),
+      updatedAt: new Date(),
+    }).where(eq(printJobs.id, id)).returning();
+    return Ok(rows[0]!);
+  }
+}

package/src/types.ts

@@ -0,0 +1,16 @@
+import type { notificationTemplates, customerNotificationPrefs, notificationLog, printJobs } from "./schema";
+
+export type { PluginDb as Db } from "@unifiedcommerce/core";
+export type NotificationTemplate = typeof notificationTemplates.$inferSelect;
+export type CustomerNotificationPref = typeof customerNotificationPrefs.$inferSelect;
+export type NotificationLogEntry = typeof notificationLog.$inferSelect;
+export type PrintJob = typeof printJobs.$inferSelect;
+export type Channel = "email" | "sms" | "push" | "print";
+export type PrefChannel = "email" | "sms" | "push";
+export type NotificationStatus = "queued" | "sent" | "delivered" | "failed";
+export type PrintJobStatus = "queued" | "printing" | "printed" | "failed";
+export type PrintJobType = "receipt" | "label" | "sticker" | "kot";
+
+/** Result type re-exports from core. */
+export { Ok, Err } from "@unifiedcommerce/core";
+export type { PluginResult as Result, PluginResultErr as ResultErr } from "@unifiedcommerce/core";