@hiliosai/sdk 0.1.12 → 0.1.14

package/src/datasources/prisma.datasource.ts

@@ -1,317 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {isDev, isTest} from '../env';
-import type {AppContext} from '../types/context';
-import {AbstractDatasource} from './base.datasource';
-
-// Generic Prisma Client interface - will be provided by generated client
-// Made very permissive to work with any generated Prisma client
-interface PrismaClientLike {
-  $connect(): Promise<void>;
-  $disconnect(): Promise<void>;
-  $queryRaw: any;
-  $transaction: any;
-  $extends: any;
-  [key: string]: any;
-}
-
-// Extension interfaces for common production patterns
-export interface SoftDeleteExtension {
-  // Adds soft delete functionality to models
-  softDelete: {
-    [model: string]: {
-      delete: (args: any) => Promise<any>;
-      deleteMany: (args: any) => Promise<any>;
-      restore: (args: any) => Promise<any>;
-    };
-  };
-}
-
-export interface AuditTrailExtension {
-  // Adds audit trail functionality
-  $auditTrail: {
-    getHistory: (model: string, id: string) => Promise<any[]>;
-    getChanges: (
-      model: string,
-      id: string,
-      from?: Date,
-      to?: Date
-    ) => Promise<any[]>;
-  };
-}
-
-export interface TenantExtension {
-  // Adds multi-tenant filtering
-  $tenant: {
-    setContext: (tenantId: string) => void;
-    getCurrentTenant: () => string | null;
-  };
-}
-
-// Global singleton pattern for Prisma Client
-declare global {
-  var __prisma: PrismaClientLike | undefined;
-}
-
-/**
- * Prisma datasource that follows singleton pattern and best practices
- * Supports both provided client instances and automatic initialization
- *
- * @example
- * ```typescript
- * // Option 1: Let datasource create singleton client
- * datasources: {
- *   prisma: PrismaDatasource
- * }
- *
- * // Option 2: Provide custom client
- * const customClient = new PrismaClient({...});
- * datasources: {
- *   prisma: () => new PrismaDatasource(customClient)
- * }
- * ```
- */
-export class PrismaDatasource<
-  TPrismaClient extends PrismaClientLike = PrismaClientLike,
-  TContext = AppContext
-> extends AbstractDatasource<TContext> {
-  readonly name = 'prisma';
-  private _client: TPrismaClient | null = null;
-  private providedClient: TPrismaClient | null = null;
-
-  constructor(prismaClient?: TPrismaClient) {
-    super();
-    this.providedClient = prismaClient ?? null;
-  }
-
-  /**
-   * Get Prisma client instance (singleton pattern)
-   */
-  get client(): TPrismaClient {
-    this._client ??= this.initializePrismaClient();
-
-    // Update tenant context from current service context
-    this.updateTenantFromContext();
-
-    return this._client;
-  }
-
-  /**
-   * Initialize Prisma client using singleton pattern or provided instance
-   */
-  private initializePrismaClient(): TPrismaClient {
-    // Option 1: Use provided client instance
-    if (this.providedClient) {
-      this.broker.logger.info('Using provided PrismaClient instance');
-      return this.providedClient;
-    }
-
-    // Option 2: Use global singleton (recommended for most cases)
-    if (!globalThis.__prisma) {
-      this.broker.logger.info('Creating new PrismaClient singleton');
-      const baseClient = this.createClient();
-      globalThis.__prisma = this.applyExtensions(baseClient);
-    } else {
-      this.broker.logger.info('Using existing PrismaClient singleton');
-    }
-
-    return globalThis.__prisma as TPrismaClient;
-  }
-
-  /**
-   * Create a new Prisma client instance
-   * Override this method in subclasses to provide the actual PrismaClient
-   */
-  protected createClient(): TPrismaClient {
-    throw new Error(
-      'createClient() must be implemented by subclass or provide PrismaClient in constructor. ' +
-        'Example: class MyPrismaDataSource extends PrismaDatasource { ' +
-        'protected createClient() { return new PrismaClient(); } }'
-    );
-  }
-
-  /**
-   * Apply extensions to the Prisma client
-   * Override this method to add production extensions like soft delete, audit trails, etc.
-   */
-  protected applyExtensions(client: TPrismaClient): TPrismaClient {
-    // Base implementation returns client as-is
-    // Override in subclass to add extensions:
-    // return client.$extends(softDeleteExtension).$extends(auditExtension)
-    return client;
-  }
-
-  /**
-   * Get extended client with all applied extensions
-   */
-  get extendedClient(): TPrismaClient {
-    return this.applyExtensions(this.client);
-  }
-
-  /**
-   * Initialize datasource - called after broker injection
-   */
-  async init(): Promise<void> {
-    this.broker.logger.info('Initializing Prisma datasource');
-  }
-
-  /**
-   * Called automatically when context is injected
-   * Sets tenant context from service context if available
-   */
-  private updateTenantFromContext(): void {
-    const tenantId = (this.context as any)?.meta?.tenantId;
-    if (tenantId && typeof tenantId === 'string') {
-      this.setTenantContext(tenantId);
-    }
-  }
-
-  /**
-   * Connect to database - called when service starts
-   */
-  async connect(): Promise<void> {
-    try {
-      this.broker.logger.info('Connecting to database via Prisma');
-      await this.client.$connect();
-      this.broker.logger.info('Successfully connected to database');
-    } catch (error) {
-      this.broker.logger.error('Failed to connect to database:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Disconnect from database - called when service stops
-   */
-  async disconnect(): Promise<void> {
-    try {
-      this.broker.logger.info('Disconnecting from database');
-      await this.client.$disconnect();
-      this.broker.logger.info('Successfully disconnected from database');
-    } catch (error) {
-      this.broker.logger.error('Error disconnecting from database:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Health check - verify database connectivity
-   */
-  async healthCheck(): Promise<boolean> {
-    try {
-      this.broker.logger.info('Running Prisma health check');
-
-      // Simple connectivity test
-      await this.client.$queryRaw`SELECT 1`;
-
-      this.broker.logger.info('Prisma health check passed');
-      return true;
-    } catch (error) {
-      this.broker.logger.error('Prisma health check failed:', error);
-      return false;
-    }
-  }
-
-  /**
-   * Clear/reset data - useful for testing
-   */
-  async clear(): Promise<void> {
-    if (isTest || isDev) {
-      this.broker.logger.warn(
-        'Clearing database (only allowed in test/dev mode)'
-      );
-
-      // Get all model names dynamically
-      const modelNames = Object.keys(this.client).filter(
-        (key) => !key.startsWith('_') && !key.startsWith('$')
-      );
-
-      // Delete all data in reverse order (to handle foreign keys)
-      for (const modelName of modelNames.reverse()) {
-        try {
-          const model = this.client[modelName as keyof TPrismaClient] as {
-            deleteMany?: () => Promise<unknown>;
-          };
-          if (model.deleteMany) {
-            await model.deleteMany();
-          }
-        } catch (error) {
-          // Some models might not support deleteMany, skip them
-          this.broker.logger.debug(`Could not clear ${modelName}:`, error);
-        }
-      }
-    } else {
-      throw new Error(
-        'Database clear is only allowed in test/development environments'
-      );
-    }
-  }
-
-  /**
-   * Transaction wrapper with proper error handling
-   */
-  async transaction<T>(
-    fn: (tx: TPrismaClient) => Promise<T>,
-    options?: {
-      maxWait?: number;
-      timeout?: number;
-    }
-  ): Promise<T> {
-    try {
-      return await this.client.$transaction(
-        (tx: any) => fn(tx as TPrismaClient),
-        options
-      );
-    } catch (error) {
-      this.broker.logger.error('Transaction failed:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Set tenant context for multi-tenant applications
-   * Requires tenant extension to be applied
-   */
-  setTenantContext(tenantId: string): void {
-    const tenantClient = this.client as any;
-    if (tenantClient.$setTenant) {
-      tenantClient.$setTenant(tenantId);
-      this.broker.logger.debug('Tenant context set:', {tenantId});
-    } else {
-      this.broker.logger.warn(
-        'Tenant extension not available - setTenantContext ignored'
-      );
-    }
-  }
-
-  /**
-   * Get current tenant context
-   */
-  getCurrentTenant(): string | null {
-    const tenantClient = this.client as any;
-    if (tenantClient.$getCurrentTenant) {
-      return tenantClient.$getCurrentTenant();
-    }
-    return null;
-  }
-
-  /**
-   * Execute with tenant context (automatically restores previous context)
-   */
-  async withTenant<T>(tenantId: string, fn: () => Promise<T>): Promise<T> {
-    const previousTenant = this.getCurrentTenant();
-
-    try {
-      this.setTenantContext(tenantId);
-      return await fn();
-    } finally {
-      if (previousTenant) {
-        this.setTenantContext(previousTenant);
-      } else {
-        const tenantClient = this.client as any;
-        if (tenantClient.$clearTenant) {
-          tenantClient.$clearTenant();
-        }
-      }
-    }
-  }
-}

package/src/env.ts

@@ -1,12 +0,0 @@
-import env from '@ltv/env';
-
-const nodeEnv = env.string('NODE_ENV', 'development');
-
-export const isDev = nodeEnv === 'development';
-export const isTest = nodeEnv === 'test';
-export const isProd = nodeEnv === 'production';
-export const REDIS_URL = env.string('REDIS_URL');
-
-export default env;
-export type Env = typeof env;
-export {nodeEnv};

package/src/errors/auth.error.ts

@@ -1,33 +0,0 @@
-export class AuthenticationError extends Error {
-  public readonly code = 'AUTH_REQUIRED';
-  public readonly statusCode = 401;
-  public readonly data: Record<string, unknown> | undefined;
-
-  constructor(message: string, data?: Record<string, unknown>) {
-    super(message);
-    this.name = 'AuthenticationError';
-    this.data = data;
-
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, AuthenticationError);
-    }
-  }
-}
-
-export class TenantError extends Error {
-  public readonly code = 'TENANT_REQUIRED';
-  public readonly statusCode = 401;
-  public readonly data: Record<string, unknown> | undefined;
-
-  constructor(message: string, data?: Record<string, unknown>) {
-    super(message);
-    this.name = 'TenantError';
-    this.data = data;
-
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, TenantError);
-    }
-  }
-}

package/src/errors/index.ts

@@ -1,2 +0,0 @@
-export * from './permission.error';
-export * from './auth.error';

package/src/errors/permission.error.ts

@@ -1,17 +0,0 @@
-export class PermissionError extends Error {
-  public readonly code = 'PERMISSION_DENIED';
-  public readonly statusCode = 403;
-  public readonly data: Record<string, unknown> | undefined;
-
-  constructor(message: string, data?: Record<string, unknown>) {
-    super(message);
-    this.name = 'PermissionError';
-    this.data = data;
-
-    // Maintains proper stack trace for where our error was thrown (only available on V8)
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, PermissionError);
-    }
-  }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-export * from './middlewares';
-export * from './service/define-service';
-export * from './service/define-integration';
-export * from './types';
-export * from './configs';
-export * from './env';
-export * from './datasources';
-export * from './mixins';
-export * from './utils';
-export {default as env} from './env';

package/src/middlewares/context-helpers.middleware.ts

@@ -1,162 +0,0 @@
-import type {AppContext, Tenant, User, UserRole} from '../types';
-import {AuthenticationError, TenantError} from '../errors';
-import {ContextCache} from '../utils/context-cache';
-import {PermissionCalculator} from '../utils/permission-calculator';
-
-export const ContextHelpersMiddleware = {
-  // Add helper functions to context before action handlers
-  localAction(handler: (...args: unknown[]) => unknown) {
-    return function ContextHelpersWrapper(this: unknown, ctx: AppContext) {
-      const cache = ContextCache.getInstance();
-
-      // Memoized permission checking with caching
-      const memoizedPermissions = new Map<string, boolean>();
-
-      ctx.hasPermission = function (permission: string): boolean {
-        // Check in-request memoization first
-        if (memoizedPermissions.has(permission)) {
-          const cachedResult = memoizedPermissions.get(permission);
-          return cachedResult === true;
-        }
-
-        const user = ctx.meta.user;
-        if (!user) {
-          memoizedPermissions.set(permission, false);
-          return false;
-        }
-
-        // Use optimized permission calculator
-        const result = PermissionCalculator.hasPermission(user, permission);
-        memoizedPermissions.set(permission, result);
-        return result;
-      };
-
-      // Cached user permissions getter
-      ctx.getUserPermissions = async function (): Promise<string[]> {
-        const user = ctx.meta.user;
-        if (!user) return [];
-
-        const cacheKey = `permissions:${user.id}:${JSON.stringify(user.roles)}`;
-        return cache.get(cacheKey, () => {
-          return PermissionCalculator.calculateUserPermissions(user);
-        });
-      };
-
-      ctx.hasRole = function (role: keyof typeof UserRole): boolean {
-        const user = ctx.ensureUser();
-        return Array.isArray(user.roles) && user.roles.includes(role);
-      };
-
-      ctx.isTenantMember = function (): boolean {
-        const user = ctx.ensureUser();
-        return !!(
-          user.tenantId &&
-          ctx.meta.tenantId &&
-          user.tenantId === ctx.meta.tenantId
-        );
-      };
-
-      ctx.isTenantOwner = function (): boolean {
-        return ctx.isTenantMember() && ctx.hasRole('OWNER');
-      };
-
-      ctx.ensureUser = (): User => {
-        if (!ctx.meta.user) {
-          ctx.broker.logger.error('Authentication required', {
-            action: ctx.action?.name,
-            requestId: ctx.meta.requestId,
-            userAgent: ctx.meta.userAgent,
-            ip: ctx.meta.clientIP,
-          });
-
-          throw new AuthenticationError('Authentication required', {
-            code: 'AUTH_REQUIRED',
-            statusCode: 401,
-            requestId: ctx.meta.requestId,
-          });
-        }
-        return ctx.meta.user;
-      };
-
-      ctx.ensureTenant = (): Tenant => {
-        if (!ctx.meta.tenantId) {
-          ctx.broker.logger.error('Tenant required', {
-            action: ctx.action?.name,
-            userId: ctx.meta.user?.id,
-            requestId: ctx.meta.requestId,
-          });
-
-          throw new TenantError('Tenant required', {
-            code: 'TENANT_REQUIRED',
-            statusCode: 401,
-            tenantId: ctx.meta.tenantId,
-            requestId: ctx.meta.requestId,
-          });
-        }
-
-        // Return a proper Tenant object with the ID
-        return {
-          id: ctx.meta.tenantId,
-          name: ctx.meta.tenantName ?? '',
-        } as Tenant;
-      };
-
-      // Enhanced audit logging function
-      ctx.auditLog = function (
-        action: string,
-        resource?: unknown,
-        metadata?: Record<string, unknown>
-      ): void {
-        ctx.broker.logger.info('Audit log', {
-          action,
-          resource: resource
-            ? {
-                type: typeof resource,
-                id: (resource as Record<string, unknown>).id,
-              }
-            : undefined,
-          userId: ctx.meta.user?.id,
-          tenantId: ctx.meta.tenantId,
-          requestId: ctx.meta.requestId,
-          timestamp: new Date().toISOString(),
-          ...metadata,
-        });
-      };
-
-      // Enhanced error creation with context
-      ctx.createError = function (
-        message: string,
-        code: string,
-        statusCode = 400
-      ): Error {
-        const errorData = {
-          code,
-          statusCode,
-          userId: ctx.meta.user?.id,
-          tenantId: ctx.meta.tenantId,
-          requestId: ctx.meta.requestId,
-          action: ctx.action?.name,
-          timestamp: new Date().toISOString(),
-        };
-
-        ctx.broker.logger.warn('Context error created', {
-          message,
-          ...errorData,
-        });
-
-        if (code === 'AUTH_REQUIRED') {
-          return new AuthenticationError(message, errorData);
-        }
-
-        if (code === 'TENANT_REQUIRED') {
-          return new TenantError(message, errorData);
-        }
-
-        return new Error(message);
-      };
-
-      // Call the original handler
-      return handler.call(this, ctx);
-    };
-  },
-};

package/src/middlewares/datasource.middleware.ts

@@ -1,73 +0,0 @@
-import type {Context} from 'moleculer';
-import type {BaseDatasource} from '../datasources';
-
-/**
- * Datasource constructor registry type
- * All datasources should implement BaseDatasource interface
- */
-export interface DatasourceConstructorRegistry {
-  [key: string]: new () => BaseDatasource | object;
-}
-
-/**
- * Datasource instance registry type
- */
-export interface DatasourceInstanceRegistry {
-  [key: string]: object;
-}
-
-/**
- * Datasource context extension
- */
-export interface DatasourceContext extends Context {
-  datasources: DatasourceInstanceRegistry;
-}
-
-/**
- * Initialize all datasources
- */
-function initializeDatasources(
-  constructorRegistry: DatasourceConstructorRegistry
-): DatasourceInstanceRegistry {
-  const initializedDatasources: DatasourceInstanceRegistry = {};
-
-  for (const [key, DatasourceClass] of Object.entries(constructorRegistry)) {
-    initializedDatasources[key] = new DatasourceClass();
-  }
-
-  return initializedDatasources;
-}
-
-/**
- * Datasource middleware that injects datasources into the context
- */
-export function createDatasourceMiddleware(
-  datasources: DatasourceConstructorRegistry
-) {
-  const initializedDatasources = initializeDatasources(datasources);
-
-  return {
-    localAction(handler: (...args: unknown[]) => unknown) {
-      return function DatasourceWrapper(this: unknown, ctx: Context) {
-        // Inject datasources into context
-        (ctx as DatasourceContext).datasources = initializedDatasources;
-        return handler.call(this, ctx);
-      };
-    },
-
-    remoteAction(handler: (...args: unknown[]) => unknown) {
-      return function DatasourceWrapper(this: unknown, ctx: Context) {
-        // Inject datasources into context for remote actions too
-        (ctx as DatasourceContext).datasources = initializedDatasources;
-        return handler.call(this, ctx);
-      };
-    },
-  };
-}
-
-/**
- * Type helper for services that use datasources
- */
-export type ServiceWithDatasources<T extends DatasourceInstanceRegistry> = {
-  datasources: T;
-};