@hiliosai/sdk 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiliosai/sdk",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "type": "module",
   "exports": {
     ".": "./src/index.ts"

package/src/configs/constants.ts

@@ -66,6 +66,19 @@ export const CHANNELS = {
   },
 } as const;
 
+/**
+ * Integration-specific channel names
+ */
+export const INTEGRATION_CHANNELS = {
+  // Message events
+  MESSAGE_RECEIVED: `${NAMESPACE}.processing.message.received`,
+  MESSAGE_SENT: `${NAMESPACE}.processing.message.sent`,
+  MESSAGE_FAILED: `${NAMESPACE}.processing.message.failed`,
+} as const;
+
+export type IntegrationChannelName =
+  (typeof INTEGRATION_CHANNELS)[keyof typeof INTEGRATION_CHANNELS];
+
 /**
  * Channel Configuration Constants
  */

package/src/datasources/base.datasource.ts

@@ -1,13 +1,29 @@
+import type {ServiceBroker} from 'moleculer';
+
+import type {AppContext} from '../types/context';
+
 /**
  * Base datasource interface that all datasources should implement
  * Provides common structure and optional lifecycle methods
  */
-export interface BaseDatasource {
+export interface BaseDatasource<TContext = AppContext> {
   /**
    * Datasource name for identification and logging
    */
   readonly name: string;
 
+  /**
+   * Service broker instance for logging, events, and service calls
+   * Always available after datasource initialization
+   */
+  broker: ServiceBroker;
+
+  /**
+   * Current service context (only available during action execution)
+   * Will be undefined in lifecycle hooks or background tasks
+   */
+  context?: TContext;
+
   /**
    * Optional initialization method
    * Called when datasource is instantiated
@@ -48,24 +64,40 @@ export interface BaseDatasource {
  *   private users: User[] = [];
  *
  *   async findById(id: string): Promise<User | undefined> {
+ *     this.broker?.logger.info('Finding user by ID:', id);
  *     return this.users.find(u => u.id === id);
  *   }
  *
- *   async create(user: User): Promise<User> {
- *     this.users.push(user);
- *     return user;
+ *   async healthCheck(): Promise<boolean> {
+ *     this.broker?.logger.info('Health check for datasource', this.name);
+ *     return true;
  *   }
  * }
  * ```
  */
-export abstract class AbstractDatasource implements BaseDatasource {
+export abstract class AbstractDatasource<TContext = AppContext>
+  implements BaseDatasource<TContext>
+{
   abstract readonly name: string;
 
+  /**
+   * Service broker instance - injected by mixin
+   * Always available after initialization
+   */
+  broker!: ServiceBroker; // Using definite assignment assertion since it's injected
+
+  /**
+   * Current service context - injected per action
+   * Only available during action execution
+   */
+  context?: TContext;
+
   /**
    * Default health check - always returns true
    * Override for custom health check logic
    */
   async healthCheck(): Promise<boolean> {
+    this.broker.logger.info(`Health check for datasource - ${this.name}`);
     return true;
   }
 

package/src/datasources/extensions/index.ts

@@ -0,0 +1,11 @@
+// Export all Prisma extensions for easy importing
+export { softDeleteExtension } from './soft-delete.extension';
+export { createTenantExtension } from './tenant.extension';
+export { retryExtension } from './retry.extension';
+
+// Re-export extension interfaces
+export type {
+  SoftDeleteExtension,
+  AuditTrailExtension,
+  TenantExtension,
+} from '../prisma.datasource';

package/src/datasources/extensions/retry.extension.ts

@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Retry Extension for Prisma Transactions
+ * Automatically retries failed transactions with exponential backoff
+ *
+ * Usage:
+ * ```typescript
+ * import { retryExtension } from './extensions/retry.extension';
+ *
+ * class MyPrismaDS extends PrismaDatasource<PrismaClient> {
+ *   protected applyExtensions(client: PrismaClient) {
+ *     return client.$extends(retryExtension);
+ *   }
+ * }
+ * ```
+ */
+
+export const retryExtension = {
+  name: 'Retry',
+
+  client: {
+    async $retryTransaction<T>(
+      fn: (tx: any) => Promise<T>,
+      options: {
+        maxRetries?: number;
+        baseDelay?: number;
+        maxDelay?: number;
+        retryableErrors?: string[];
+      } = {}
+    ): Promise<T> {
+      const {
+        maxRetries = 3,
+        baseDelay = 100,
+        maxDelay = 5000,
+        retryableErrors = [
+          'P2034', // Transaction failed due to a write conflict
+          'P2002', // Unique constraint failed
+          'P5000', // Raw query failed
+        ],
+      } = options;
+
+      let lastError: Error | undefined;
+
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          return await (this as any).$transaction(fn, {
+            timeout: 10000,
+            maxWait: 5000,
+          });
+        } catch (error: any) {
+          lastError = error;
+
+          // Check if error is retryable
+          const isRetryable = retryableErrors.some(
+            (code) => error.code === code || error.message?.includes(code)
+          );
+
+          if (!isRetryable || attempt === maxRetries) {
+            throw error;
+          }
+
+          // Calculate delay with exponential backoff and jitter
+          const delay = Math.min(
+            baseDelay * Math.pow(2, attempt) + Math.random() * 100,
+            maxDelay
+          );
+
+          // Log retry attempt (in production, use proper logger)
+          if (
+            typeof globalThis !== 'undefined' &&
+            (globalThis as any).console
+          ) {
+            (globalThis as any).console.warn(
+              `Transaction retry ${
+                attempt + 1
+              }/${maxRetries} after ${delay}ms:`,
+              {
+                error: error.message,
+                code: error.code,
+              }
+            );
+          }
+
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+      }
+
+      throw lastError ?? new Error('Transaction failed after maximum retries');
+    },
+  },
+};

package/src/datasources/extensions/soft-delete.extension.ts

@@ -0,0 +1,113 @@
+/**
+ * Soft Delete Extension for Prisma
+ * Automatically handles soft deletes by setting deletedAt instead of removing records
+ *
+ * Usage:
+ * ```typescript
+ * import { softDeleteExtension } from './extensions/soft-delete.extension';
+ *
+ * class MyPrismaDS extends PrismaDatasource<PrismaClient> {
+ *   protected applyExtensions(client: PrismaClient) {
+ *     return client.$extends(softDeleteExtension);
+ *   }
+ * }
+ * ```
+ *
+ * Requires models to have `deletedAt DateTime?` field
+ */
+
+export const softDeleteExtension = {
+  name: 'SoftDelete',
+
+  query: {
+    // Apply to all models
+    $allModels: {
+      // Override findMany to exclude soft deleted records
+      async findMany({args, query}: any) {
+        // Add deletedAt: null filter if not already specified
+        args.where ??= {};
+        if (args.where.deletedAt === undefined) {
+          args.where.deletedAt = null;
+        }
+        return query(args);
+      },
+
+      // Override findUnique to exclude soft deleted records
+      async findUnique({args, query}: any) {
+        args.where ??= {};
+        if (args.where.deletedAt === undefined) {
+          args.where.deletedAt = null;
+        }
+        return query(args);
+      },
+
+      // Override findFirst to exclude soft deleted records
+      async findFirst({args, query}: any) {
+        args.where ??= {};
+        if (args.where.deletedAt === undefined) {
+          args.where.deletedAt = null;
+        }
+        return query(args);
+      },
+
+      // Override delete to set deletedAt instead
+      async delete({args, query}: any) {
+        return query({
+          ...args,
+          data: {deletedAt: new Date()},
+        });
+      },
+
+      // Override deleteMany to set deletedAt instead
+      async deleteMany({args, query}: any) {
+        return query({
+          ...args,
+          data: {deletedAt: new Date()},
+        });
+      },
+    },
+  },
+
+  model: {
+    $allModels: {
+      // Add restore method to all models
+      async restore<T>(this: T, where: any): Promise<any> {
+        const context =
+          (globalThis as any).Prisma?.getExtensionContext?.(this) ?? this;
+
+        return (context as any).update({
+          where,
+          data: {deletedAt: null},
+        });
+      },
+
+      // Add findWithDeleted method to include soft deleted records
+      async findWithDeleted<T>(this: T, args: any): Promise<any> {
+        const context =
+          (globalThis as any).Prisma?.getExtensionContext?.(this) ?? this;
+
+        return (context as any).findMany({
+          ...args,
+          where: {
+            ...args.where,
+            // Don't filter by deletedAt
+          },
+        });
+      },
+
+      // Add findDeleted method to find only soft deleted records
+      async findDeleted<T>(this: T, args: any): Promise<any> {
+        const context =
+          (globalThis as any).Prisma?.getExtensionContext?.(this) ?? this;
+
+        return (context as any).findMany({
+          ...args,
+          where: {
+            ...args.where,
+            deletedAt: {not: null},
+          },
+        });
+      },
+    },
+  },
+};

package/src/datasources/extensions/tenant.extension.ts

@@ -0,0 +1,104 @@
+/**
+ * Multi-Tenant Extension for Prisma
+ * Automatically filters queries by tenant context for multi-tenant applications
+ * 
+ * Usage:
+ * ```typescript
+ * import { createTenantExtension } from './extensions/tenant.extension';
+ * 
+ * class MyPrismaDS extends PrismaDatasource<PrismaClient> {
+ *   protected applyExtensions(client: PrismaClient) {
+ *     return client.$extends(createTenantExtension());
+ *   }
+ * }
+ * ```
+ * 
+ * Requires models to have `tenantId String` field
+ */
+
+interface TenantContext {
+  currentTenantId: string | null;
+}
+
+export function createTenantExtension() {
+  const tenantContext: TenantContext = {
+    currentTenantId: null,
+  };
+
+  return {
+    name: 'Tenant',
+    
+    client: {
+      // Set tenant context
+      $setTenant(tenantId: string) {
+        tenantContext.currentTenantId = tenantId;
+      },
+      
+      // Get current tenant
+      $getCurrentTenant() {
+        return tenantContext.currentTenantId;
+      },
+      
+      // Clear tenant context
+      $clearTenant() {
+        tenantContext.currentTenantId = null;
+      },
+    },
+    
+    query: {
+      $allModels: {
+        // Automatically add tenantId filter to all read operations
+        async findMany({ args, query }: any) {
+          if (tenantContext.currentTenantId) {
+            args.where ??= {};
+            args.where.tenantId ??= tenantContext.currentTenantId;
+          }
+          return query(args);
+        },
+        
+        async findUnique({ args, query }: any) {
+          if (tenantContext.currentTenantId) {
+            args.where ??= {};
+            args.where.tenantId ??= tenantContext.currentTenantId;
+          }
+          return query(args);
+        },
+        
+        async findFirst({ args, query }: any) {
+          if (tenantContext.currentTenantId) {
+            args.where ??= {};
+            args.where.tenantId ??= tenantContext.currentTenantId;
+          }
+          return query(args);
+        },
+        
+        // Automatically add tenantId to create operations
+        async create({ args, query }: any) {
+          if (tenantContext.currentTenantId) {
+            args.data ??= {};
+            args.data.tenantId ??= tenantContext.currentTenantId;
+          }
+          return query(args);
+        },
+        
+        // Add tenantId filter to update operations
+        async update({ args, query }: any) {
+          if (tenantContext.currentTenantId) {
+            args.where ??= {};
+            args.where.tenantId ??= tenantContext.currentTenantId;
+          }
+          return query(args);
+        },
+        
+        // Add tenantId filter to delete operations
+        async delete({ args, query }: any) {
+          if (tenantContext.currentTenantId) {
+            args.where ??= {};
+            args.where.tenantId ??= tenantContext.currentTenantId;
+          }
+          return query(args);
+        },
+      },
+    },
+  };
+}

package/src/datasources/index.ts

@@ -1 +1,3 @@
 export * from './base.datasource';
+export * from './prisma.datasource';
+export * from './extensions';