@bernierllc/chat-suite 1.0.0

package/src/utils/message-bridge.ts

@@ -0,0 +1,164 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import type { ProviderType, ProviderMessage, MessageBridgeConfig } from '../types';
+
+/**
+ * Bridged message information
+ */
+export interface BridgedMessage {
+  originalMessageId: string;
+  sourceProvider: ProviderType;
+  targetProvider: ProviderType;
+  targetMessageId?: string;
+  timestamp: Date;
+}
+
+/**
+ * Message bridge for cross-platform synchronization
+ */
+export class MessageBridge {
+  private bridgedMessages: Map<string, BridgedMessage[]> = new Map();
+  private channelMappings: Map<string, string> = new Map();
+
+  constructor(private config: MessageBridgeConfig) {
+    if (config.channelMappings) {
+      this.channelMappings = config.channelMappings;
+    }
+  }
+
+  /**
+   * Check if message should be bridged
+   */
+  public shouldBridge(sourceProvider: ProviderType, targetProvider: ProviderType): boolean {
+    if (!this.config.enabled) {
+      return false;
+    }
+
+    return this.config.sourceProviders.includes(sourceProvider) &&
+           this.config.targetProviders.includes(targetProvider);
+  }
+
+  /**
+   * Transform message for target provider
+   */
+  public transformMessage(
+    message: ProviderMessage,
+    sourceProvider: ProviderType,
+    targetProvider: ProviderType
+  ): ProviderMessage {
+    const transformed: ProviderMessage = {
+      ...message,
+      metadata: {
+        ...message.metadata,
+        bridged: true,
+        sourceProvider,
+        originalContent: message.content
+      }
+    };
+
+    // Map channel if mapping exists
+    if (message.channelId) {
+      const mappedChannel = this.getMappedChannel(message.channelId, sourceProvider, targetProvider);
+      if (mappedChannel) {
+        transformed.channelId = mappedChannel;
+      }
+    }
+
+    // Add source provider prefix to content
+    transformed.content = `[From ${sourceProvider}] ${message.content}`;
+
+    return transformed;
+  }
+
+  /**
+   * Record a bridged message
+   */
+  public recordBridgedMessage(bridgedMessage: BridgedMessage): void {
+    const existing = this.bridgedMessages.get(bridgedMessage.originalMessageId) || [];
+    existing.push(bridgedMessage);
+    this.bridgedMessages.set(bridgedMessage.originalMessageId, existing);
+  }
+
+  /**
+   * Get all bridges for a message
+   */
+  public getBridges(originalMessageId: string): BridgedMessage[] {
+    return this.bridgedMessages.get(originalMessageId) || [];
+  }
+
+  /**
+   * Add channel mapping
+   */
+  public addChannelMapping(sourceChannel: string, targetChannel: string): void {
+    this.channelMappings.set(sourceChannel, targetChannel);
+  }
+
+  /**
+   * Get mapped channel
+   */
+  public getMappedChannel(
+    sourceChannel: string,
+    _sourceProvider: ProviderType,
+    _targetProvider: ProviderType
+  ): string | undefined {
+    return this.channelMappings.get(sourceChannel);
+  }
+
+  /**
+   * Check if reactions should be synced
+   */
+  public shouldSyncReactions(): boolean {
+    return this.config.syncReactions ?? false;
+  }
+
+  /**
+   * Check if edits should be synced
+   */
+  public shouldSyncEdits(): boolean {
+    return this.config.syncEdits ?? false;
+  }
+
+  /**
+   * Check if deletions should be synced
+   */
+  public shouldSyncDeletions(): boolean {
+    return this.config.syncDeletions ?? false;
+  }
+
+  /**
+   * Clear all bridged message records
+   */
+  public clear(): void {
+    this.bridgedMessages.clear();
+  }
+
+  /**
+   * Get statistics
+   */
+  public getStats(): {
+    totalBridged: number;
+    bridgesByProvider: Map<ProviderType, number>;
+  } {
+    const bridgesByProvider = new Map<ProviderType, number>();
+    let total = 0;
+
+    this.bridgedMessages.forEach(bridges => {
+      bridges.forEach(bridge => {
+        const count = bridgesByProvider.get(bridge.targetProvider) || 0;
+        bridgesByProvider.set(bridge.targetProvider, count + 1);
+        total++;
+      });
+    });
+
+    return {
+      totalBridged: total,
+      bridgesByProvider
+    };
+  }
+}

package/src/utils/user-mapping.ts

@@ -0,0 +1,132 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import type { ProviderType } from '../types';
+
+/**
+ * User identity across platforms
+ */
+export interface UserIdentity {
+  unifiedId: string;
+  platformIds: Map<ProviderType, string>;
+  displayName?: string;
+  email?: string;
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * User mapping storage
+ */
+export class UserMapper {
+  private identities: Map<string, UserIdentity> = new Map();
+  private providerIndex: Map<string, string> = new Map(); // provider:userId -> unifiedId
+
+  /**
+   * Create or update a user identity
+   */
+  public mapUser(identity: UserIdentity): void {
+    this.identities.set(identity.unifiedId, identity);
+
+    // Update provider index
+    identity.platformIds.forEach((platformUserId, provider) => {
+      const key = this.getProviderKey(provider, platformUserId);
+      this.providerIndex.set(key, identity.unifiedId);
+    });
+  }
+
+  /**
+   * Get unified user ID from platform-specific ID
+   */
+  public getUnifiedId(provider: ProviderType, platformUserId: string): string | undefined {
+    const key = this.getProviderKey(provider, platformUserId);
+    return this.providerIndex.get(key);
+  }
+
+  /**
+   * Get platform-specific user ID from unified ID
+   */
+  public getPlatformId(unifiedId: string, provider: ProviderType): string | undefined {
+    const identity = this.identities.get(unifiedId);
+    return identity?.platformIds.get(provider);
+  }
+
+  /**
+   * Get full user identity
+   */
+  public getIdentity(unifiedId: string): UserIdentity | undefined {
+    return this.identities.get(unifiedId);
+  }
+
+  /**
+   * Add platform ID to existing user
+   */
+  public addPlatformId(unifiedId: string, provider: ProviderType, platformUserId: string): boolean {
+    const identity = this.identities.get(unifiedId);
+    if (!identity) {
+      return false;
+    }
+
+    identity.platformIds.set(provider, platformUserId);
+    this.mapUser(identity);
+    return true;
+  }
+
+  /**
+   * Remove user identity
+   */
+  public removeUser(unifiedId: string): boolean {
+    const identity = this.identities.get(unifiedId);
+    if (!identity) {
+      return false;
+    }
+
+    // Remove from provider index
+    identity.platformIds.forEach((platformUserId, provider) => {
+      const key = this.getProviderKey(provider, platformUserId);
+      this.providerIndex.delete(key);
+    });
+
+    return this.identities.delete(unifiedId);
+  }
+
+  /**
+   * Get all users
+   */
+  public getAllUsers(): UserIdentity[] {
+    return Array.from(this.identities.values());
+  }
+
+  /**
+   * Clear all mappings
+   */
+  public clear(): void {
+    this.identities.clear();
+    this.providerIndex.clear();
+  }
+
+  /**
+   * Get number of mapped users
+   */
+  public size(): number {
+    return this.identities.size;
+  }
+
+  /**
+   * Create provider key for indexing
+   */
+  private getProviderKey(provider: ProviderType, platformUserId: string): string {
+    return `${provider}:${platformUserId}`;
+  }
+}
+
+/**
+ * Create a new unified user ID
+ */
+export function createUnifiedId(): string {
+  return `user_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "types": ["node"],
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "__tests__"]
+}