@theelena/shared 1.0.1 → 1.0.2

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@theelena/shared",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
-  "main": "./index.js",
-  "types": "./index.ts",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
   "exports": {
     ".": {
       "types": "./src/index.ts",
@@ -17,6 +17,9 @@
     }
   },
   "files": [
-    "dist"
-  ]
+    "src"
+  ],
+  "devDependencies": {
+    "typescript": "^5"
+  }
 }

package/src/events/base.ts

@@ -0,0 +1,153 @@
+/**
+ * Event scope types for channel routing
+ */
+export type EventScope = "restaurant" | "user" | "global";
+
+/**
+ * Context required for channel resolution
+ */
+export interface EventContext {
+  restaurantId: string;
+  userId: string;
+}
+
+/**
+ * Serialized event format for SSE transmission
+ */
+export interface SerializedEvent<TData = unknown> {
+  type: string;
+  data: TData;
+  timestamp: number;
+}
+
+/**
+ * Channel name generators for event routing
+ */
+export const EventChannels = {
+  restaurant: (restaurantId: string) => `restaurant:${restaurantId}`,
+  user: (userId: string) => `user:${userId}`,
+  global: () => "global",
+} as const;
+
+/**
+ * Base class for all application events
+ *
+ * Scope is automatically deduced from event type prefix:
+ * - 'order.*', 'product.*', 'sale.*', 'customer.*' → restaurant scope
+ * - 'notification.*', 'system.*' → user scope (owner messages)
+ * - default → global scope
+ *
+ * @example
+ * ```typescript
+ * class OrderCreatedEvent extends BaseEvent<OrderCreatedData> {
+ *   readonly type = 'order.created' as const;
+ * }
+ *
+ * const event = new OrderCreatedEvent({ orderId: '123', ... });
+ * const channel = event.getChannel({ restaurantId: 'abc', userId: 'xyz' });
+ * // Returns: 'restaurant:abc'
+ * ```
+ */
+export abstract class BaseEvent<TData = unknown> {
+  /**
+   * Event type identifier - used for routing and filtering
+   * Convention: '{domain}.{action}' e.g., 'order.created', 'notification.sent'
+   */
+  abstract readonly type: string;
+
+  /**
+   * Event payload data
+   */
+  readonly data: TData;
+
+  /**
+   * Event creation timestamp (milliseconds since epoch)
+   */
+  readonly timestamp: number;
+
+  constructor(data: TData) {
+    this.data = data;
+    this.timestamp = Date.now();
+  }
+
+  /**
+   * Deduce scope from event type prefix
+   * Override in subclass if custom scope logic is needed
+   */
+  protected getScope(): EventScope {
+    const domain = this.type.split(".")[0] ?? "";
+
+    const restaurantDomains = ["order", "product", "sale", "customer", "table", "category"];
+    if (restaurantDomains.includes(domain)) {
+      return "restaurant";
+    }
+
+    const userDomains = ["notification", "system", "alert"];
+    if (userDomains.includes(domain)) {
+      return "user";
+    }
+
+    return "global";
+  }
+
+  /**
+   * Get the Redis channel for this event based on context
+   */
+  getChannel(context: EventContext): string {
+    const scope = this.getScope();
+
+    switch (scope) {
+      case "restaurant":
+        return EventChannels.restaurant(context.restaurantId);
+      case "user":
+        return EventChannels.user(context.userId);
+      case "global":
+        return EventChannels.global();
+    }
+  }
+
+  /**
+   * Get all channels this event should be published to
+   * By default, only returns the primary channel
+   * Override for multi-channel publishing
+   */
+  getChannels(context: EventContext): string[] {
+    return [this.getChannel(context)];
+  }
+
+  /**
+   * Serialize event for transmission
+   */
+  toJSON(): SerializedEvent<TData> {
+    return {
+      type: this.type,
+      data: this.data,
+      timestamp: this.timestamp,
+    };
+  }
+
+  /**
+   * Create event instance from serialized data
+   * Must be implemented by concrete event classes for deserialization
+   */
+  static fromJSON<T extends BaseEvent>(
+    this: new (data: any) => T,
+    json: SerializedEvent
+  ): T {
+    return new this(json.data);
+  }
+}
+
+/**
+ * Type helper to extract data type from event class
+ */
+export type EventData<E extends BaseEvent> = E extends BaseEvent<infer D>
+  ? D
+  : never;
+
+/**
+ * Type helper for event class constructor
+ */
+export type EventClass<E extends BaseEvent = BaseEvent> = new (
+  data: EventData<E>
+) => E;

package/src/events/index.ts

@@ -0,0 +1,3 @@
+export * from "./base";
+export * from "./order.events";
+export * from "./notification.events";

package/src/events/notification.events.ts

@@ -0,0 +1,23 @@
+import { BaseEvent } from "./base";
+
+export interface SystemNotificationData {
+  title: string;
+  message: string;
+  severity: "info" | "warning" | "error" | "success";
+  actionUrl?: string;
+}
+
+export interface AlertData {
+  alertId: string;
+  alertType: string;
+  message: string;
+  metadata?: Record<string, unknown>;
+}
+
+export class SystemNotificationEvent extends BaseEvent<SystemNotificationData> {
+  readonly type = "system.notification" as const;
+}
+
+export class AlertEvent extends BaseEvent<AlertData> {
+  readonly type = "alert.triggered" as const;
+}

package/src/events/order.events.ts

@@ -0,0 +1,25 @@
+import { BaseEvent } from "./base";
+
+export interface OrderCreatedData {
+  orderId: string;
+  orderNumber: string;
+  orderType: "takeout" | "dine_in" | "reservation";
+  customerName?: string;
+  tableName?: string;
+}
+
+export interface OrderStatusChangedData {
+  orderId: string;
+  orderNumber: string;
+  oldStatus: string;
+  newStatus: string;
+  updatedBy: string;
+}
+
+export class OrderCreatedEvent extends BaseEvent<OrderCreatedData> {
+  readonly type = "order.created" as const;
+}
+
+export class OrderStatusChangedEvent extends BaseEvent<OrderStatusChangedData> {
+  readonly type = "order.status_changed" as const;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export * from "./events";