@hiliosai/sdk 0.1.12 → 0.1.14

package/src/datasources/base.datasource.ts

@@ -1,111 +0,0 @@
-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<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
-   */
-  init?(): Promise<void> | void;
-
-  /**
-   * Optional connection method
-   * Called when service starts if implemented
-   */
-  connect?(): Promise<void> | void;
-
-  /**
-   * Optional disconnection method
-   * Called when service stops if implemented
-   */
-  disconnect?(): Promise<void> | void;
-
-  /**
-   * Optional health check method
-   * Can be used to verify datasource is working correctly
-   */
-  healthCheck?(): Promise<boolean> | boolean;
-
-  /**
-   * Optional method to clear/reset the datasource
-   */
-  clear?(): Promise<void> | void;
-}
-
-/**
- * Abstract base class for datasources that provides default implementations
- * @example
- * ```typescript
- * export class UserDatasource extends AbstractDatasource {
- *   readonly name = 'users';
- *
- *   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 healthCheck(): Promise<boolean> {
- *     this.broker?.logger.info('Health check for datasource', this.name);
- *     return true;
- *   }
- * }
- * ```
- */
-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;
-  }
-
-  /**
-   * Default clear method - does nothing
-   * Override to implement clearing logic
-   */
-  async clear(): Promise<void> {
-    // Default implementation - does nothing
-  }
-}

package/src/datasources/extensions/index.ts

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

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

@@ -1,114 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * 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

@@ -1,105 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/**
- * 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,3 +0,0 @@
-export * from './base.datasource';
-export * from './prisma.datasource';
-export * from './extensions';