@hiliosai/sdk 0.1.12 → 0.1.15

package/src/mixins/datasource.mixin.ts

@@ -1,111 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import type {ServiceSchema} from 'moleculer';
-import type {
-  DatasourceConstructorRegistry,
-  DatasourceInstanceRegistry,
-} from '../middlewares/datasource.middleware';
-import type {AppContext} from '../types/context';
-
-/**
- * Creates a Moleculer mixin for datasource injection
- * Simple mixin that just instantiates datasources and injects them into context
- *
- * @example
- * ```typescript
- * import {DatasourceMixin} from '@pkg/sdk';
- *
- * export default {
- *   name: 'users',
- *   mixins: [DatasourceMixin({
- *     userDb: UserDatasource,
- *     cache: CacheDatasource,
- *   })],
- *   actions: {
- *     get: {
- *       handler(ctx) {
- *         // Access datasources via ctx.datasources
- *         return ctx.datasources.userDb.findById(ctx.params.id);
- *       }
- *     }
- *   }
- * }
- * ```
- */
-export function DatasourceMixin(
-  datasourceConstructors: DatasourceConstructorRegistry = {}
-): Partial<ServiceSchema> {
-  // Initialize datasources once
-  const datasourceInstances: DatasourceInstanceRegistry = {};
-
-  for (const [key, DatasourceClass] of Object.entries(datasourceConstructors)) {
-    datasourceInstances[key] = new DatasourceClass();
-  }
-
-  return {
-    /**
-     * Service created lifecycle hook
-     * Initialize datasources and store on service
-     */
-    async created() {
-      // Inject broker into datasources
-      for (const [, datasource] of Object.entries(datasourceInstances)) {
-        (datasource as any).broker = this.broker;
-      }
-
-      // Call init() on datasources that have it
-      for (const [, datasource] of Object.entries(datasourceInstances)) {
-        if (typeof (datasource as any).init === 'function') {
-          await (datasource as any).init();
-        }
-      }
-
-      // Store instances on the service for access in methods
-      (this as any).$datasources = datasourceInstances;
-    },
-
-    /**
-     * Service started lifecycle hook
-     * Connect datasources that have connect method
-     */
-    async started() {
-      // Call connect() on datasources that have it
-      for (const [, datasource] of Object.entries(datasourceInstances)) {
-        if (typeof (datasource as any).connect === 'function') {
-          await (datasource as any).connect();
-        }
-      }
-    },
-
-    /**
-     * Service stopped lifecycle hook
-     * Disconnect datasources that have disconnect method
-     */
-    async stopped() {
-      // Call disconnect() on datasources that have it
-      for (const [, datasource] of Object.entries(datasourceInstances)) {
-        if (typeof (datasource as any).disconnect === 'function') {
-          await (datasource as any).disconnect();
-        }
-      }
-    },
-
-    /**
-     * Hooks to inject datasources into context
-     */
-    hooks: {
-      before: {
-        '*': function injectDatasources(ctx) {
-          const datasources = (this as any).$datasources ?? {};
-
-          // Inject current context into all datasources
-          for (const [, datasource] of Object.entries(datasources)) {
-            (datasource as any).context = ctx;
-          }
-
-          // Inject datasources into the context
-          (ctx as AppContext).datasources = datasources;
-        },
-      },
-    },
-  };
-}

package/src/mixins/index.ts

@@ -1 +0,0 @@
-export * from './datasource.mixin';

package/src/service/define-integration.ts

@@ -1,404 +0,0 @@
-import crypto from 'crypto';
-
-import {CHANNEL_CONFIG, INTEGRATION_CHANNELS} from '../configs/constants';
-import type {DatasourceConstructorRegistry} from '../middlewares/datasource.middleware';
-import {
-  type IntegrationMessageFailedPayload,
-  type IntegrationMessageReceivedPayload,
-  type IntegrationMessageSentPayload,
-} from '../types/channels';
-import type {AppContext} from '../types/context';
-import type {IntegrationConfig} from '../types/integration';
-import type {Message, SendResult, WebhookEvent} from '../types/message';
-import type {DatasourceInstanceTypes} from '../types/datasource';
-import type {
-  IntegrationServiceConfig,
-  IntegrationServiceSchema,
-} from '../types/service';
-import {defineService} from './define-service';
-
-/**
- * Security helpers for webhook validation
- */
-const SecurityHelpers = {
-  /**
-   * Secure comparison using Node.js crypto.timingSafeEqual
-   */
-  secureCompare(a: string, b: string): boolean {
-    try {
-      return crypto.timingSafeEqual(
-        Buffer.from(a, 'utf8'),
-        Buffer.from(b, 'utf8')
-      );
-    } catch {
-      return false;
-    }
-  },
-
-  /**
-   * Validate webhook timestamp to prevent replay attacks
-   */
-  validateTimestamp(timestamp: number, maxAgeMs = 5 * 60 * 1000): boolean {
-    return Date.now() - timestamp <= maxAgeMs;
-  },
-};
-
-/**
- * Retry mechanism with exponential backoff
- */
-async function executeWithRetry<T>(
-  operation: () => Promise<T>,
-  maxRetries = 3,
-  baseDelayMs = 1000,
-  context = 'operation'
-): Promise<T> {
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error: unknown) {
-      if (attempt === maxRetries) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        throw new Error(
-          `${context} failed after ${maxRetries} retries: ${err.message}`
-        );
-      }
-
-      const delay = baseDelayMs * Math.pow(2, attempt);
-      const jitter = Math.random() * 1000;
-      await new Promise((resolve) => setTimeout(resolve, delay + jitter));
-    }
-  }
-  throw new Error('Retry logic error');
-}
-
-export function defineIntegration<
-  TSettings = unknown,
-  TDatasourceConstructors extends DatasourceConstructorRegistry = DatasourceConstructorRegistry
->(
-  config: IntegrationServiceConfig<TSettings, TDatasourceConstructors>
-): IntegrationServiceSchema<TSettings> {
-  // Type alias for inferred datasource instances
-  type TDatasources = DatasourceInstanceTypes<TDatasourceConstructors>;
-
-  // Create actions from integration methods
-  const actions = {
-    i_receiveWebhook: {
-      rest: {
-        method: 'POST' as const,
-        path: '/:channelId',
-      },
-      params: {
-        channelId: 'string',
-        payload: 'object',
-        headers: 'object',
-        timestamp: 'number',
-      },
-      async handler(
-        ctx: AppContext<
-          TDatasources,
-          {
-            channelId: string;
-            payload: object;
-            headers: object;
-            timestamp: number;
-          }
-        >
-      ): Promise<{success: boolean; messages: number; failed: number}> {
-        const {channelId, payload, headers, timestamp} = ctx.params;
-
-        // TODO: Look up channel configuration by channelId
-        // const channel = await getChannelConfig(channelId);
-        // For now, we'll construct webhook from meta
-
-        const webhook: WebhookEvent = {
-          tenantId: ctx.meta.tenantId ?? 'unknown', // Should come from channel lookup
-          channelId,
-          platform: config.spec.platform,
-          payload, // Raw webhook payload from gateway
-          headers: headers as Record<string, string>,
-          timestamp,
-        };
-
-        // Validate timestamp to prevent replay attacks
-        if (!SecurityHelpers.validateTimestamp(webhook.timestamp)) {
-          throw new Error('Webhook timestamp too old - possible replay attack');
-        }
-
-        // Validate webhook if method exists
-        if (config.validateWebhook) {
-          const isValid = await config.validateWebhook(webhook);
-          if (!isValid) {
-            throw new Error('Invalid webhook payload format');
-          }
-        }
-
-        // Validate signature if method exists
-        if (config.validateSignature) {
-          const isValidSignature = config.validateSignature(webhook);
-          if (!isValidSignature) {
-            throw new Error('Webhook signature validation failed');
-          }
-        }
-
-        // Normalize the message
-        const normalizedMessages = await config.normalize(webhook);
-
-        // Process each message with reliable delivery (parallel)
-        const results = await Promise.allSettled(
-          normalizedMessages.map(async (message) => {
-            const payload: IntegrationMessageReceivedPayload = {
-              tenantId: webhook.tenantId,
-              channelId: webhook.channelId,
-              platform: webhook.platform,
-              message,
-              timestamp: Date.now(),
-            };
-
-            // Send to reliable message channel (NATS JetStream)
-            return ctx.broker.sendToChannel(
-              INTEGRATION_CHANNELS.MESSAGE_RECEIVED,
-              payload,
-              CHANNEL_CONFIG.HIGH_PRIORITY
-            );
-          })
-        );
-
-        // Count successful vs failed messages
-        const successful = results.filter(
-          (result) => result.status === 'fulfilled'
-        ).length;
-        const failed = results.filter(
-          (result) => result.status === 'rejected'
-        ).length;
-
-        // Log failures for monitoring (but don't fail the entire webhook)
-        if (failed > 0) {
-          const failures = results
-            .filter((result) => result.status === 'rejected')
-            .map((result) => (result as PromiseRejectedResult).reason);
-
-          ctx.broker.logger.warn(
-            `Webhook processing partial failure: ${failed}/${normalizedMessages.length} messages failed`,
-            {failures}
-          );
-        }
-
-        return {success: true, messages: successful, failed};
-      },
-    },
-
-    i_sendMessage: {
-      rest: {
-        method: 'POST' as const,
-        path: '/send',
-      },
-      params: {
-        message: 'object',
-        channelId: 'string',
-      },
-      async handler(
-        ctx: AppContext<
-          TDatasources,
-          {
-            message: Message;
-            channelId: string;
-          }
-        >
-      ): Promise<SendResult> {
-        const {message, channelId} = ctx.params;
-
-        // Load channel configuration
-        const integrationConfig = await config.getChannelConfig(ctx, channelId);
-        if (!integrationConfig) {
-          throw new Error(`Channel configuration not found: ${channelId}`);
-        }
-
-        // Send the message with retry mechanism (transformation happens inside sendMessage)
-        const result: SendResult = await executeWithRetry(
-          () => config.sendMessage(ctx, message, integrationConfig),
-          3,
-          1000,
-          `Send message via ${config.spec.platform}`
-        );
-
-        // Send reliable events based on result (with error handling)
-        try {
-          if (result.success) {
-            const sentPayload: IntegrationMessageSentPayload = {
-              tenantId: integrationConfig.tenantId,
-              channelId,
-              platform: config.spec.platform,
-              messageId: result.messageId,
-              metadata: result.metadata,
-              timestamp: Date.now(),
-            };
-
-            await ctx.broker.sendToChannel(
-              INTEGRATION_CHANNELS.MESSAGE_SENT,
-              sentPayload,
-              CHANNEL_CONFIG.DEFAULTS
-            );
-          } else {
-            const failedPayload: IntegrationMessageFailedPayload = {
-              tenantId: integrationConfig.tenantId,
-              channelId,
-              platform: config.spec.platform,
-              error: result.error?.message ?? 'Unknown error',
-              message,
-              timestamp: Date.now(),
-            };
-
-            await ctx.broker.sendToChannel(
-              INTEGRATION_CHANNELS.MESSAGE_FAILED,
-              failedPayload,
-              CHANNEL_CONFIG.DEFAULTS
-            );
-          }
-        } catch (channelError: unknown) {
-          // Log channel error but don't fail the send operation
-          const err =
-            channelError instanceof Error
-              ? channelError
-              : new Error(String(channelError));
-          ctx.broker.logger.warn('Failed to send message event to channel', {
-            error: err.message,
-            messageId: result.messageId,
-            platform: config.spec.platform,
-          });
-        }
-
-        return result;
-      },
-    },
-
-    i_healthCheck: {
-      rest: {
-        method: 'GET' as const,
-        path: '/health',
-      },
-      params: {
-        config: {type: 'object', optional: true},
-      },
-      async handler(
-        ctx: AppContext<TDatasources, {config?: IntegrationConfig}>
-      ): Promise<unknown> {
-        try {
-          if (config.checkHealth) {
-            const integrationConfig = ctx.params.config;
-            if (integrationConfig) {
-              return await config.checkHealth(ctx, integrationConfig);
-            }
-          }
-
-          return {
-            status: 'healthy',
-            message: `${config.spec.name} integration is running`,
-            details: {
-              id: config.spec.id,
-              version: config.spec.version,
-              timestamp: new Date().toISOString(),
-              capabilities: config.spec.capabilities,
-            },
-          };
-        } catch (error: unknown) {
-          const err = error instanceof Error ? error : new Error(String(error));
-          return {
-            status: 'unhealthy',
-            message: err.message,
-            details: {
-              id: config.spec.id,
-              timestamp: new Date().toISOString(),
-            },
-          };
-        }
-      },
-    },
-
-    i_verifyWebhook: {
-      rest: {
-        method: 'GET' as const,
-        path: '/:tenantId',
-      },
-      params: {
-        tenantId: 'string',
-        mode: 'string',
-        token: 'string',
-        challenge: 'string',
-      },
-      handler(
-        ctx: AppContext<
-          TDatasources,
-          {tenantId: string; mode: string; token: string; challenge: string}
-        >
-      ): string {
-        if (config.verifyWebhook) {
-          const result: string | null = config.verifyWebhook(ctx.params);
-          return result ?? '';
-        }
-        return ctx.params.challenge;
-      },
-    },
-
-    i_validateCredentials: {
-      params: {
-        credentials: 'object',
-      },
-      async handler(
-        ctx: AppContext<TDatasources, {credentials: Record<string, string>}>
-      ): Promise<boolean> {
-        if (config.validateCredentials) {
-          return await config.validateCredentials(ctx.params.credentials);
-        }
-        return true;
-      },
-    },
-  };
-
-  // Add any custom actions
-  if (config.actions) {
-    Object.assign(actions, config.actions);
-  }
-
-  // Use defineService to get all the mixins and proper setup
-  const baseService = defineService<TSettings, TDatasourceConstructors>({
-    name: config.name,
-    version: config.version,
-    settings: config.settings as TSettings,
-    dependencies: config.dependencies,
-    datasources: config.datasources,
-    metadata: {
-      ...config.metadata,
-      spec: config.spec,
-    },
-    actions,
-    events: config.events ?? {},
-    methods: {
-      ...(config.methods ?? {}),
-      // Add integration-specific methods to the service methods (filter out undefined)
-      // Required methods - no need for conditional
-      normalize: config.normalize,
-      getChannelConfig: config.getChannelConfig,
-      sendMessage: config.sendMessage,
-      // Optional methods
-      ...(config.validateWebhook && {validateWebhook: config.validateWebhook}),
-      ...(config.verifyWebhook && {verifyWebhook: config.verifyWebhook}),
-      ...(config.checkHealth && {checkHealth: config.checkHealth}),
-      ...(config.validateCredentials && {
-        validateCredentials: config.validateCredentials,
-      }),
-      ...(config.validateSignature && {
-        validateSignature: config.validateSignature,
-      }),
-    },
-    created: config.created,
-    started: config.started,
-    stopped: config.stopped,
-  });
-
-  // Return the service schema - integration methods are available via service methods
-  return {
-    ...baseService,
-    // Only add the integration spec
-    spec: config.spec,
-  } as IntegrationServiceSchema<TSettings>;
-}

package/src/service/define-service.ts

@@ -1,58 +0,0 @@
-import type {ServiceSchema as MoleculerServiceSchema} from 'moleculer';
-
-import {MemoizeMixin} from '../middlewares';
-import type {DatasourceConstructorRegistry} from '../middlewares/datasource.middleware';
-import {DatasourceMixin} from '../mixins';
-import type {ServiceConfig} from '../types/service';
-import {omit} from '../utils';
-
-/**
- * Define a service
- *
- * @example
- * ```typescript
- * export default defineService({
- *   name: 'user',
- *
- *   actions: {
- *     // Action with schema
- *     getUser: {
- *       params: {
- *         id: 'string'
- *       },
- *       handler(ctx) {
- *         const { tenantId } = ctx.meta;
- *
- *         return { id: ctx.params.id, tenantId };
- *       }
- *     },
- *
- *     // Direct handler
- *     listUsers(ctx) {
- *       return [];
- *     }
- *   }
- * });
- * ```
- */
-export function defineService<
-  TSettings = unknown,
-  TDatasourceConstructors extends DatasourceConstructorRegistry = DatasourceConstructorRegistry
->(
-  config: ServiceConfig<TSettings, TDatasourceConstructors>
-): MoleculerServiceSchema<TSettings> {
-  const propsToOmit = ['datasources'];
-  const serviceSchema = omit(
-    config,
-    propsToOmit
-  ) as unknown as MoleculerServiceSchema<TSettings>;
-
-  return {
-    ...serviceSchema,
-    mixins: [
-      DatasourceMixin(config.datasources),
-      MemoizeMixin(),
-      ...(serviceSchema.mixins ?? []),
-    ],
-  };
-}

package/src/types/channels.ts

@@ -1,60 +0,0 @@
-import type {IntegrationPlatform} from './platform';
-import type {Message} from './message';
-
-/**
- * Channel event payload types for reliable messaging via @moleculer/channels
- */
-
-// Integration message events
-export interface IntegrationMessageReceivedPayload {
-  tenantId: string;
-  channelId: string;
-  platform: IntegrationPlatform;
-  message: Message;
-  timestamp: number;
-  metadata?: Record<string, unknown>;
-}
-
-export interface IntegrationMessageSentPayload {
-  tenantId: string;
-  channelId: string;
-  platform: IntegrationPlatform;
-  messageId?: string;
-  metadata?: Record<string, unknown>;
-  timestamp: number;
-}
-
-export interface IntegrationMessageFailedPayload {
-  tenantId: string;
-  channelId: string;
-  platform: IntegrationPlatform;
-  error: string; // Serialized error message
-  message?: Message;
-  timestamp: number;
-  retryCount?: number;
-  metadata?: Record<string, unknown>;
-}
-
-// System events
-export interface IntegrationRegisteredPayload {
-  tenantId: string;
-  channelId: string;
-  platform: IntegrationPlatform;
-  config: Record<string, unknown>;
-  timestamp: number;
-}
-
-export interface IntegrationUnregisteredPayload {
-  tenantId: string;
-  channelId: string;
-  platform: IntegrationPlatform;
-  timestamp: number;
-}
-
-// Re-export constants to avoid duplication
-export {
-  CHANNELS,
-  INTEGRATION_CHANNELS,
-  NAMESPACE,
-  type IntegrationChannelName,
-} from '../configs/constants';

package/src/types/context.ts

@@ -1,64 +0,0 @@
-import type {Context} from 'moleculer';
-import type {Tenant} from './tenant';
-import type {User} from './user';
-
-// Moleculer Channels types
-export interface ChannelSendOptions {
-  group?: string;
-  maxInFlight?: number;
-  maxRetries?: number;
-  deadLettering?: {
-    enabled?: boolean;
-    queueName?: string;
-  };
-}
-
-export interface SendToChannelMethod {
-  (
-    channelName: string,
-    payload: unknown,
-    options?: ChannelSendOptions
-  ): Promise<void>;
-}
-
-export interface AppMeta {
-  user?: User;
-  tenantId?: string;
-  tenantName?: string;
-  userId?: string;
-  channelId?: string;
-  requestId?: string;
-  userAgent?: string;
-  clientIP?: string;
-  [key: string]: unknown;
-}
-
-export interface PermissionHelpers {
-  hasPermission(permission: string): boolean;
-  hasRole(role: string): boolean;
-  isTenantMember(): boolean;
-  isTenantOwner(): boolean;
-  ensureUser(): User;
-  ensureTenant(): Tenant;
-  // New enhanced helpers
-  getUserPermissions(): Promise<string[]>;
-  auditLog(
-    action: string,
-    resource?: unknown,
-    metadata?: Record<string, unknown>
-  ): void;
-  createError(message: string, code: string, statusCode?: number): Error;
-}
-
-export type AppContext<
-  TDatasources = unknown,
-  TParams = unknown,
-  TMeta extends AppMeta = AppMeta,
-  TLocals = unknown
-> = Context<TParams, TMeta, TLocals> &
-  PermissionHelpers & {
-    datasources: TDatasources;
-    broker: Context['broker'] & {
-      sendToChannel: SendToChannelMethod;
-    };
-  };