@theelena/shared 1.0.2 → 1.0.4

package/dist/chunk-DAZIRU7I.js

@@ -0,0 +1,112 @@
+// src/events/base.ts
+var EventChannels = {
+  restaurant: (restaurantId) => `restaurant:${restaurantId}`,
+  user: (userId) => `user:${userId}`,
+  global: () => "global"
+};
+var BaseEvent = class {
+  /**
+   * Event payload data
+   */
+  data;
+  /**
+   * Event creation timestamp (milliseconds since epoch)
+   */
+  timestamp;
+  constructor(data) {
+    this.data = data;
+    this.timestamp = Date.now();
+  }
+  /**
+   * Deduce scope from event type prefix
+   * Override in subclass if custom scope logic is needed
+   */
+  getScope() {
+    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) {
+    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) {
+    return [this.getChannel(context)];
+  }
+  /**
+   * Serialize event for transmission
+   */
+  toJSON() {
+    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(json) {
+    return new this(json.data);
+  }
+};
+
+// src/events/order.events.ts
+var OrderCreatedEvent = class extends BaseEvent {
+  type = "order.created";
+};
+var OrderStatusChangedEvent = class extends BaseEvent {
+  type = "order.status_changed";
+};
+
+// src/events/table.events.ts
+var TableStatusChangedEvent = class extends BaseEvent {
+  type = "table.status_changed";
+};
+
+// src/events/notification.events.ts
+var SystemNotificationEvent = class extends BaseEvent {
+  type = "system.notification";
+};
+var AlertEvent = class extends BaseEvent {
+  type = "alert.triggered";
+};
+
+// src/events/staff.events.ts
+var StaffJoinedEvent = class extends BaseEvent {
+  type = "staff.joined";
+};
+
+export {
+  EventChannels,
+  BaseEvent,
+  OrderCreatedEvent,
+  OrderStatusChangedEvent,
+  TableStatusChangedEvent,
+  SystemNotificationEvent,
+  AlertEvent,
+  StaffJoinedEvent
+};

package/dist/events/index.d.ts

@@ -0,0 +1,172 @@
+/**
+ * Event scope types for channel routing
+ */
+type EventScope = "restaurant" | "user" | "global";
+/**
+ * Context required for channel resolution
+ */
+interface EventContext {
+    restaurantId: string;
+    userId: string;
+}
+/**
+ * Serialized event format for SSE transmission
+ */
+interface SerializedEvent<TData = unknown> {
+    type: string;
+    data: TData;
+    timestamp: number;
+}
+/**
+ * Channel name generators for event routing
+ */
+declare const EventChannels: {
+    readonly restaurant: (restaurantId: string) => string;
+    readonly user: (userId: string) => string;
+    readonly global: () => string;
+};
+/**
+ * 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'
+ * ```
+ */
+declare 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);
+    /**
+     * Deduce scope from event type prefix
+     * Override in subclass if custom scope logic is needed
+     */
+    protected getScope(): EventScope;
+    /**
+     * Get the Redis channel for this event based on context
+     */
+    getChannel(context: EventContext): string;
+    /**
+     * 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[];
+    /**
+     * Serialize event for transmission
+     */
+    toJSON(): SerializedEvent<TData>;
+    /**
+     * 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;
+}
+/**
+ * Type helper to extract data type from event class
+ */
+type EventData<E extends BaseEvent> = E extends BaseEvent<infer D> ? D : never;
+/**
+ * Type helper for event class constructor
+ */
+type EventClass<E extends BaseEvent = BaseEvent> = new (data: EventData<E>) => E;
+
+interface OrderCreatedData {
+    orderId: string;
+    orderNumber: string;
+    orderType: "takeout" | "dine_in" | "reservation";
+    customerName?: string;
+    tableName?: string;
+}
+interface OrderStatusChangedData {
+    orderId: string;
+    orderNumber: string;
+    oldStatus: string;
+    newStatus: string;
+    updatedBy: string;
+}
+declare class OrderCreatedEvent extends BaseEvent<OrderCreatedData> {
+    readonly type: "order.created";
+}
+declare class OrderStatusChangedEvent extends BaseEvent<OrderStatusChangedData> {
+    readonly type: "order.status_changed";
+}
+
+interface TableStatusChangedData {
+    tableId: string;
+    tableNumber: string;
+    oldStatus: "disponible" | "ocupada" | "reservada";
+    newStatus: "disponible" | "ocupada" | "reservada";
+    reason?: string;
+}
+declare class TableStatusChangedEvent extends BaseEvent<TableStatusChangedData> {
+    readonly type: "table.status_changed";
+}
+
+interface SystemNotificationData {
+    title: string;
+    message: string;
+    severity: "info" | "warning" | "error" | "success";
+    actionUrl?: string;
+}
+interface AlertData {
+    alertId: string;
+    alertType: string;
+    message: string;
+    metadata?: Record<string, unknown>;
+}
+declare class SystemNotificationEvent extends BaseEvent<SystemNotificationData> {
+    readonly type: "system.notification";
+}
+declare class AlertEvent extends BaseEvent<AlertData> {
+    readonly type: "alert.triggered";
+}
+
+/**
+ * Staff Events
+ * Module: Staff Management (Module 15)
+ *
+ * Events related to staff members joining organizations
+ */
+
+interface StaffJoinedData {
+    memberId: string;
+    userName: string;
+    userEmail: string;
+    role: string;
+    restaurantId: string;
+    restaurantName: string;
+    joinedAt: string;
+}
+/**
+ * StaffJoinedEvent
+ * Fired when a new staff member accepts an invitation and joins an organization
+ * Scope: restaurant (prefix "staff.*" → routes to restaurant:{restaurantId})
+ */
+declare class StaffJoinedEvent extends BaseEvent<StaffJoinedData> {
+    readonly type: "staff.joined";
+}
+
+export { type AlertData, AlertEvent, BaseEvent, EventChannels, type EventClass, type EventContext, type EventData, type EventScope, type OrderCreatedData, OrderCreatedEvent, type OrderStatusChangedData, OrderStatusChangedEvent, type SerializedEvent, type StaffJoinedData, StaffJoinedEvent, type SystemNotificationData, SystemNotificationEvent, type TableStatusChangedData, TableStatusChangedEvent };

package/dist/events/index.js

@@ -0,0 +1,20 @@
+import {
+  AlertEvent,
+  BaseEvent,
+  EventChannels,
+  OrderCreatedEvent,
+  OrderStatusChangedEvent,
+  StaffJoinedEvent,
+  SystemNotificationEvent,
+  TableStatusChangedEvent
+} from "../chunk-DAZIRU7I.js";
+export {
+  AlertEvent,
+  BaseEvent,
+  EventChannels,
+  OrderCreatedEvent,
+  OrderStatusChangedEvent,
+  StaffJoinedEvent,
+  SystemNotificationEvent,
+  TableStatusChangedEvent
+};

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { AlertData, AlertEvent, BaseEvent, EventChannels, EventClass, EventContext, EventData, EventScope, OrderCreatedData, OrderCreatedEvent, OrderStatusChangedData, OrderStatusChangedEvent, SerializedEvent, StaffJoinedData, StaffJoinedEvent, SystemNotificationData, SystemNotificationEvent, TableStatusChangedData, TableStatusChangedEvent } from './events/index.js';

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  AlertEvent,
+  BaseEvent,
+  EventChannels,
+  OrderCreatedEvent,
+  OrderStatusChangedEvent,
+  StaffJoinedEvent,
+  SystemNotificationEvent,
+  TableStatusChangedEvent
+} from "./chunk-DAZIRU7I.js";
+export {
+  AlertEvent,
+  BaseEvent,
+  EventChannels,
+  OrderCreatedEvent,
+  OrderStatusChangedEvent,
+  StaffJoinedEvent,
+  SystemNotificationEvent,
+  TableStatusChangedEvent
+};

package/package.json

@@ -1,25 +1,28 @@
 {
   "name": "@theelena/shared",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     },
     "./events": {
-      "types": "./src/events/index.ts",
-      "import": "./src/events/index.ts",
-      "default": "./src/events/index.ts"
+      "types": "./dist/events/index.d.ts",
+      "import": "./dist/events/index.js"
     }
   },
   "files": [
-    "src"
+    "dist"
   ],
+  "scripts": {
+    "build": "tsup src/index.ts src/events/index.ts --format esm --dts --out-dir dist",
+    "build:watch": "tsup src/index.ts src/events/index.ts --format esm --dts --out-dir dist --watch"
+  },
   "devDependencies": {
+    "tsup": "^8.0.2",
     "typescript": "^5"
   }
 }

package/src/events/base.ts

@@ -1,153 +0,0 @@
-/**
- * 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

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

package/src/events/notification.events.ts

@@ -1,23 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

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