@hiliosai/sdk 0.1.0

package/src/types/message.ts

@@ -0,0 +1,95 @@
+import type {IntegrationPlatform} from './platform';
+
+export interface MessageParticipant {
+  id: string;
+  name?: string;
+  avatar?: string;
+  metadata?: Record<string, any>;
+}
+
+export enum MessageContentType {
+  TEXT = 'text',
+  IMAGE = 'image',
+  VIDEO = 'video',
+  AUDIO = 'audio',
+  FILE = 'file',
+  LOCATION = 'location',
+  BUTTONS = 'buttons',
+  CAROUSEL = 'carousel',
+  REACTION = 'reaction',
+}
+
+export interface MessageContent {
+  type: MessageContentType;
+  text?: string;
+  media?: {
+    url: string;
+    mimeType?: string;
+    size?: number;
+    thumbnail?: string;
+  };
+  location?: {
+    latitude: number;
+    longitude: number;
+    address?: string;
+  };
+  buttons?: MessageButton[];
+  carousel?: CarouselItem[];
+  reaction?: {
+    emoji: string;
+    messageId: string;
+  };
+  metadata?: Record<string, any>;
+}
+
+export interface MessageButton {
+  id: string;
+  text: string;
+  type: 'postback' | 'url' | 'call';
+  payload?: string;
+  url?: string;
+  phoneNumber?: string;
+}
+
+export interface CarouselItem {
+  title: string;
+  subtitle?: string;
+  imageUrl?: string;
+  buttons?: MessageButton[];
+}
+
+export interface NormalizedMessage {
+  id: string;
+  conversationId: string;
+  from: MessageParticipant;
+  to: MessageParticipant;
+  content: MessageContent;
+  timestamp: number;
+  platform: IntegrationPlatform;
+  replyTo?: string;
+  threadId?: string;
+  metadata?: Record<string, any>;
+}
+
+export interface PlatformMessage {
+  platform: IntegrationPlatform;
+  rawPayload: any;
+}
+
+export interface WebhookEvent {
+  tenantId: string;
+  channelId: string;
+  integrationId: string;
+  platform: IntegrationPlatform;
+  rawPayload: any;
+  rawBody?: string;
+  headers: Record<string, string>;
+  timestamp: number;
+}
+
+export interface SendResult {
+  success: boolean;
+  messageId?: string;
+  error?: Error;
+  metadata?: Record<string, any>;
+}

package/src/types/platform.ts

@@ -0,0 +1,39 @@
+export enum IntegrationPlatform {
+  WHATSAPP = 'whatsapp',
+  TELEGRAM = 'telegram',
+  SLACK = 'slack',
+  EMAIL = 'email',
+  SMS = 'sms',
+  INSTAGRAM = 'instagram',
+  FACEBOOK = 'facebook',
+  DISCORD = 'discord',
+  WEBCHAT = 'webchat',
+  CUSTOM = 'custom',
+}
+
+export enum IntegrationStatus {
+  CONFIGURED = 'CONFIGURED',
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+  ERROR = 'ERROR',
+  SUSPENDED = 'SUSPENDED',
+}
+
+export enum IntegrationCapability {
+  SEND_MESSAGE = 'send_message',
+  RECEIVE_MESSAGE = 'receive_message',
+  SEND_IMAGE = 'send_image',
+  SEND_VIDEO = 'send_video',
+  SEND_AUDIO = 'send_audio',
+  SEND_FILE = 'send_file',
+  SEND_LOCATION = 'send_location',
+  SEND_BUTTONS = 'send_buttons',
+  SEND_CAROUSEL = 'send_carousel',
+  TYPING_INDICATOR = 'typing_indicator',
+  READ_RECEIPT = 'read_receipt',
+  GROUP_CHAT = 'group_chat',
+  REACTIONS = 'reactions',
+  THREADS = 'threads',
+  VOICE_CALL = 'voice_call',
+  VIDEO_CALL = 'video_call',
+}

package/src/types/service.ts

@@ -0,0 +1,208 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type {
+  ActionSchema,
+  ServiceSchema as MoleculerServiceSchema,
+  ServiceEvents,
+  ServiceHooks,
+  ServiceMethods,
+} from 'moleculer';
+
+import type {DatasourceConstructorRegistry} from '../middlewares/datasource.middleware';
+import type {CacheOptions} from '../middlewares/cache.middleware';
+import type {AppContext} from './context';
+import type {BaseIntegration, IntegrationConfig} from './integration';
+import type {
+  NormalizedMessage,
+  PlatformMessage,
+  SendResult,
+  WebhookEvent,
+} from './message';
+
+// Type to infer TypeScript types from Moleculer parameter schemas
+type InferParamsType<T> = T extends Record<string, any>
+  ? {
+      [K in keyof T]: T[K] extends 'string'
+        ? string
+        : T[K] extends 'number'
+        ? number
+        : T[K] extends 'boolean'
+        ? boolean
+        : T[K] extends 'array'
+        ? any[]
+        : T[K] extends 'object'
+        ? Record<string, any>
+        : T[K] extends {type: 'string'}
+        ? string
+        : T[K] extends {type: 'number'}
+        ? number
+        : T[K] extends {type: 'boolean'}
+        ? boolean
+        : T[K] extends {type: 'array'}
+        ? any[]
+        : T[K] extends {type: 'object'}
+        ? Record<string, any>
+        : unknown;
+    }
+  : unknown;
+
+// Action schema with automatic parameter type inference
+export type ActionSchemaWithContext<
+  TDatasources = unknown,
+  TParams = unknown
+> = Pick<
+  ActionSchema,
+  | 'name'
+  | 'rest'
+  | 'visibility'
+  | 'service'
+  | 'cache'
+  | 'tracing'
+  | 'bulkhead'
+  | 'circuitBreaker'
+  | 'retryPolicy'
+  | 'fallback'
+  | 'hooks'
+> & {
+  params?: TParams;
+  handler: (
+    ctx: AppContext<TDatasources, InferParamsType<TParams>>
+  ) => Promise<unknown> | unknown;
+  permissions?: string | string[];
+};
+
+// Direct action handler type
+export type ActionHandler<TDatasources = unknown> = (
+  ctx: AppContext<TDatasources>
+) => Promise<unknown> | unknown;
+
+// Service actions - individual action type will handle inference
+export type ServiceActionsSchema<TDatasources = unknown> = {
+  [key: string]:
+    | ({
+        params?: any;
+        handler: (
+          ctx: AppContext<TDatasources, any>
+        ) => Promise<unknown> | unknown;
+        permissions?: string | string[];
+      } & Pick<
+        ActionSchema,
+        | 'name'
+        | 'rest'
+        | 'visibility'
+        | 'service'
+        | 'cache'
+        | 'tracing'
+        | 'bulkhead'
+        | 'circuitBreaker'
+        | 'retryPolicy'
+        | 'fallback'
+        | 'hooks'
+      >)
+    | ActionHandler<TDatasources>
+    | false;
+};
+
+// Custom ServiceSchema that uses our action schema
+export interface ServiceSchema<TSettings = unknown, TDatasources = unknown>
+  extends Omit<MoleculerServiceSchema<TSettings>, 'actions'> {
+  name: string;
+  version?: string | number;
+  settings?: TSettings;
+  actions?: ServiceActionsSchema<TDatasources>;
+  events?: ServiceEvents;
+  methods?: ServiceMethods;
+  hooks?: ServiceHooks;
+  dependencies?: string | string[];
+  metadata?: Record<string, any>;
+  created?: (this: MoleculerServiceSchema<TSettings>) => void | Promise<void>;
+  started?: (this: MoleculerServiceSchema<TSettings>) => void | Promise<void>;
+  stopped?: (this: MoleculerServiceSchema<TSettings>) => void | Promise<void>;
+}
+
+// ServiceConfig is what users provide to defineService
+export type ServiceConfig<
+  TSettings = unknown,
+  TDatasources = unknown
+> = ServiceSchema<TSettings, TDatasources> & {
+  datasources?: DatasourceConstructorRegistry;
+  cache?: CacheOptions;
+};
+
+// Integration-specific types
+export interface IntegrationServiceConfig<
+  TPlatformMessage extends PlatformMessage = PlatformMessage,
+  TSettings = unknown,
+  TContext extends AppContext = AppContext
+> extends Omit<ServiceConfig<TSettings>, 'name'> {
+  name: string;
+  integration: BaseIntegration;
+
+  // Core integration methods
+  normalize(webhook: WebhookEvent): Promise<NormalizedMessage[]>;
+  transform?(
+    message: NormalizedMessage,
+    config: IntegrationConfig
+  ): Promise<TPlatformMessage>;
+  validateWebhook?(webhook: WebhookEvent): boolean;
+  sendMessage(
+    ctx: TContext,
+    message: NormalizedMessage,
+    config: IntegrationConfig
+  ): Promise<SendResult>;
+
+  // Optional webhook verification
+  verifyWebhook?(params: {
+    mode: string;
+    token: string;
+    challenge: string;
+  }): string | null;
+
+  // Optional health check
+  checkHealth?(
+    ctx: TContext,
+    config: IntegrationConfig
+  ): Promise<{
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    message?: string;
+    details?: Record<string, any>;
+  }>;
+
+  // Optional credential validation
+  validateCredentials?(credentials: Record<string, string>): Promise<boolean>;
+
+  // Optional signature validation
+  validateSignature?(webhook: WebhookEvent): boolean;
+}
+
+export interface IntegrationServiceSchema<
+  TPlatformMessage extends PlatformMessage = PlatformMessage,
+  TSettings = unknown
+> extends MoleculerServiceSchema<TSettings> {
+  integration: BaseIntegration;
+  normalize(webhook: WebhookEvent): Promise<NormalizedMessage[]>;
+  transform?(
+    message: NormalizedMessage,
+    config: IntegrationConfig
+  ): Promise<TPlatformMessage>;
+  validateWebhook?(webhook: WebhookEvent): boolean;
+  sendMessage(
+    ctx: AppContext,
+    message: NormalizedMessage,
+    config: IntegrationConfig
+  ): Promise<SendResult>;
+  verifyWebhook?(params: {
+    mode: string;
+    token: string;
+    challenge: string;
+  }): string | null;
+  checkHealth?(
+    ctx: AppContext,
+    config: IntegrationConfig
+  ): Promise<{
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    message?: string;
+    details?: Record<string, any>;
+  }>;
+  validateCredentials?(credentials: Record<string, string>): Promise<boolean>;
+  validateSignature?(webhook: WebhookEvent): boolean;
+}

package/src/types/tenant.ts

@@ -0,0 +1,4 @@
+export interface Tenant {
+  id: string;
+  name: string;
+}

package/src/types/user.ts

@@ -0,0 +1,16 @@
+export const UserRole = {
+  OWNER: 'OWNER',
+  ADMIN: 'ADMIN',
+  MANAGER: 'MANAGER',
+  AGENT: 'AGENT',
+  VIEWER: 'VIEWER'
+} as const
+
+export interface User {
+  id: string;
+  email: string;
+  roles: string[];
+  permissions: string[];
+  tenantId: string;
+  name: string;
+}

package/src/utils/context-cache.ts

@@ -0,0 +1,70 @@
+interface CacheEntry {
+  value: unknown;
+  timestamp: number;
+}
+
+export class ContextCache {
+  private static instance: ContextCache;
+  private memoryCache = new Map<string, CacheEntry>();
+  private readonly TTL = 5 * 60 * 1000; // 5 minutes
+  private cleanupInterval: NodeJS.Timeout;
+
+  private constructor() {
+    // Cleanup expired entries every minute
+    this.cleanupInterval = setInterval(() => this.cleanup(), 60 * 1000);
+  }
+
+  static getInstance(): ContextCache {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!ContextCache.instance) {
+      ContextCache.instance = new ContextCache();
+    }
+    return ContextCache.instance;
+  }
+
+  async get<T>(key: string, factory: () => Promise<T> | T): Promise<T> {
+    const cached = this.memoryCache.get(key);
+
+    if (cached && Date.now() - cached.timestamp < this.TTL) {
+      return cached.value as T;
+    }
+
+    const value = await factory();
+    this.memoryCache.set(key, {value, timestamp: Date.now()});
+
+    return value;
+  }
+
+  set<T>(key: string, value: T): void {
+    this.memoryCache.set(key, {value, timestamp: Date.now()});
+  }
+
+  delete(key: string): boolean {
+    return this.memoryCache.delete(key);
+  }
+
+  clear(): void {
+    this.memoryCache.clear();
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    const keysToDelete: string[] = [];
+
+    this.memoryCache.forEach((entry, key) => {
+      if (now - entry.timestamp > this.TTL) {
+        keysToDelete.push(key);
+      }
+    });
+
+    keysToDelete.forEach((key) => this.memoryCache.delete(key));
+  }
+
+  destroy(): void {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.clear();
+  }
+}

package/src/utils/permission-calculator.ts

@@ -0,0 +1,62 @@
+import {ROLE_PERMISSIONS} from '../configs';
+import type {User} from '../types';
+
+export class PermissionCalculator {
+  static calculateUserPermissions(user: User): string[] {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!user || !Array.isArray(user.roles)) {
+      return [];
+    }
+
+    // Combine explicit permissions with role-based permissions
+    const explicitPermissions = Array.isArray(user.permissions)
+      ? user.permissions
+      : [];
+
+    // Get all permissions from user's roles
+    const rolePermissions = user.roles.flatMap((role: string) => {
+      return ROLE_PERMISSIONS[role] ?? [];
+    });
+
+    // Remove duplicates and return
+    const allPermissions = [...explicitPermissions, ...rolePermissions];
+    const uniquePermissions: string[] = [];
+
+    allPermissions.forEach((permission) => {
+      if (!uniquePermissions.includes(permission)) {
+        uniquePermissions.push(permission);
+      }
+    });
+
+    return uniquePermissions;
+  }
+
+  static hasPermission(user: User, permission: string): boolean {
+    if (typeof permission !== 'string' || !permission.trim()) {
+      return false;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (!user || typeof user !== 'object') {
+      return false;
+    }
+
+    if (!Array.isArray(user.roles)) {
+      return false;
+    }
+
+    // Check explicit permissions first
+    if (
+      Array.isArray(user.permissions) &&
+      user.permissions.includes(permission)
+    ) {
+      return true;
+    }
+
+    // Check role-based permissions
+    return user.roles.some((role: string) => {
+      const rolePermissions = ROLE_PERMISSIONS[role] ?? [];
+      return rolePermissions.includes(permission);
+    });
+  }
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@hiliosai/typescript/base.json",
+  "compilerOptions": {
+    "incremental": true,
+    "tsBuildInfoFile": "node_modules/.cache/tsbuildinfo.json",
+    "paths": {
+      "@pkg/*": ["../*/dist"]
+    },
+    "baseUrl": "."
+  },
+  "include": ["*.ts", "src", "src/types/**/*"],
+  "exclude": ["node_modules"]
+}

package/tsup.config.ts

@@ -0,0 +1,6 @@
+ 
+import {defineConfig} from '@pkg/dev-utils';
+
+export default defineConfig({
+  entry: ['src/index.ts'],
+});