@hiliosai/sdk 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -46,6 +46,7 @@ interface AppMeta {
     requestId?: string;
     userAgent?: string;
     clientIP?: string;
+    startTime?: Date;
     [key: string]: unknown;
 }
 interface PermissionHelpers {
@@ -899,6 +900,15 @@ type Env = typeof env;
  */
 declare function DatasourceMixin(datasourceConstructors?: DatasourceConstructorRegistry): Partial<ServiceSchema$1>;
 
+/**
+ * Determines the appropriate log level based on error code/status
+ */
+declare function getErrorLogLevel(code?: string | number): 'fatal' | 'error' | 'warn' | 'info';
+/**
+ * Sanitizes error data to remove sensitive information
+ */
+declare function sanitizeErrorData(data: unknown): unknown;
+
 declare function omit<T extends Record<string, unknown>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;
 
 declare class PermissionError extends Error {
@@ -948,10 +958,10 @@ interface GatewayError extends Error {
  *   }
  * }
  */
-declare const gatewayErrorHandler: (req: IncomingMessage & {
+declare function gatewayErrorHandler(this: Service, req: IncomingMessage & {
     $ctx?: AppContext;
     originalUrl?: string;
-}, res: ServerResponse, error: GatewayError) => void;
+}, res: ServerResponse, error: GatewayError): void;
 
 declare class DBError extends Errors.MoleculerError {
     constructor(message: string, code: number, type?: string, data?: unknown);
@@ -974,6 +984,6 @@ declare class DBTimeoutError extends Errors.MoleculerError {
 declare class DBTransactionError extends Errors.MoleculerError {
     constructor(message: string, data?: unknown);
 }
-declare const prismaErrorHandler: (err: Error, info: BrokerErrorHandlerInfoAction) => undefined;
+declare function prismaErrorHandler(this: ServiceBroker, err: Error, info: BrokerErrorHandlerInfoAction): undefined;
 
-export { AbstractDatasource, type ActionHandler, type ActionWithPermissions, type AppContext, type AppMeta, type AuditTrailExtension, AuthenticationError, type BaseDatasource, type BaseSpec, CHANNELS, type CarouselItem, type ChannelSendOptions, ContextHelpersMiddleware, CreateHealthCheckMiddleware, DBConnectionError, DBConstraintError, DBError, DBNotFoundError, DBTimeoutError, DBTransactionError, DBValidationError, DEFAULT_DATASOURCE_CACHE_TTL, type DatasourceConstructorRegistry, type DatasourceContext, type DatasourceInstanceRegistry, type DatasourceInstanceTypes, DatasourceMixin, type Env, type GatewayError, HEALTH_CHECK_DEFAULTS, INTEGRATION_CHANNELS, IntegrationCapability, type IntegrationChannelName, type IntegrationConfig, type IntegrationMessageFailedPayload, type IntegrationMessageReceivedPayload, type IntegrationMessageSentPayload, IntegrationPlatform, type IntegrationRegisteredPayload, type IntegrationServiceConfig, type IntegrationServiceSchema, IntegrationStatus, type IntegrationUnregisteredPayload, MemoizeMixin, type MemoizeMixinOptions, type Message, type MessageAttachment, type MessageButton, type MessageContent, MessageContentType, type MessageDirection, type MessageParticipant, type MessageStatus, type MessageType, NAMESPACE, PERMISSIONS, type Permission, PermissionError, type PermissionHelpers, PermissionsMiddleware, type PlatformMessage, type PrismaClientLike, type PrismaClientWithTenant, PrismaDatasource, PrismaPgDatasource, REDIS_URL, ROLE_PERMISSIONS, type SendResult, type SendToChannelMethod, type ServiceActionsSchema, type ServiceConfig, type ServiceSchema, type ServiceWithDatasources, type SoftDeleteExtension, type Tenant, TenantError, type TenantExtension, type User, UserRole, type WebhookEvent, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, gatewayErrorHandler, isDev, isProd, isTest, configs as moleculer, nodeEnv, omit, prismaErrorHandler, retryExtension, softDeleteExtension };
+export { AbstractDatasource, type ActionHandler, type ActionWithPermissions, type AppContext, type AppMeta, type AuditTrailExtension, AuthenticationError, type BaseDatasource, type BaseSpec, CHANNELS, type CarouselItem, type ChannelSendOptions, ContextHelpersMiddleware, CreateHealthCheckMiddleware, DBConnectionError, DBConstraintError, DBError, DBNotFoundError, DBTimeoutError, DBTransactionError, DBValidationError, DEFAULT_DATASOURCE_CACHE_TTL, type DatasourceConstructorRegistry, type DatasourceContext, type DatasourceInstanceRegistry, type DatasourceInstanceTypes, DatasourceMixin, type Env, type GatewayError, HEALTH_CHECK_DEFAULTS, INTEGRATION_CHANNELS, IntegrationCapability, type IntegrationChannelName, type IntegrationConfig, type IntegrationMessageFailedPayload, type IntegrationMessageReceivedPayload, type IntegrationMessageSentPayload, IntegrationPlatform, type IntegrationRegisteredPayload, type IntegrationServiceConfig, type IntegrationServiceSchema, IntegrationStatus, type IntegrationUnregisteredPayload, MemoizeMixin, type MemoizeMixinOptions, type Message, type MessageAttachment, type MessageButton, type MessageContent, MessageContentType, type MessageDirection, type MessageParticipant, type MessageStatus, type MessageType, NAMESPACE, PERMISSIONS, type Permission, PermissionError, type PermissionHelpers, PermissionsMiddleware, type PlatformMessage, type PrismaClientLike, type PrismaClientWithTenant, PrismaDatasource, PrismaPgDatasource, REDIS_URL, ROLE_PERMISSIONS, type SendResult, type SendToChannelMethod, type ServiceActionsSchema, type ServiceConfig, type ServiceSchema, type ServiceWithDatasources, type SoftDeleteExtension, type Tenant, TenantError, type TenantExtension, type User, UserRole, type WebhookEvent, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, gatewayErrorHandler, getErrorLogLevel, isDev, isProd, isTest, configs as moleculer, nodeEnv, omit, prismaErrorHandler, retryExtension, sanitizeErrorData, softDeleteExtension };

package/dist/index.js

@@ -300,9 +300,9 @@ var TenantError = class _TenantError extends Error {
 };
 
 // src/errors/gateway.error.ts
-var gatewayErrorHandler = (req, res, error) => {
+function gatewayErrorHandler(req, res, error) {
   res.setHeader("Content-Type", "application/json; charset=utf-8");
-  const statusCode = error.code ?? error.statusCode ?? 500;
+  const statusCode = typeof error.code === "number" ? error.code : typeof error.statusCode === "number" ? error.statusCode : 500;
   res.writeHead(statusCode);
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   const requestId = req.$ctx?.id ?? req.$ctx?.requestID;
@@ -349,8 +349,21 @@ var gatewayErrorHandler = (req, res, error) => {
       ...docLinks[errorCode] && { help: docLinks[errorCode] }
     }
   };
+  const logLevel = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "info";
+  this.logger[logLevel]("API Gateway Error", {
+    code: errorCode,
+    statusCode,
+    message: error.message,
+    requestId,
+    path,
+    method: req.method,
+    timestamp,
+    details: details.length > 0 ? details : void 0,
+    stack: statusCode >= 500 ? error.stack : void 0,
+    data: error.data
+  });
   res.end(JSON.stringify(response));
-};
+}
 var DBError = class extends Errors.MoleculerError {
   constructor(message, code, type = "DB_ERROR", data) {
     super(message, code, type, data);
@@ -386,33 +399,46 @@ var DBTransactionError = class extends Errors.MoleculerError {
     super(message, 500, "TRANSACTION_ERROR", data);
   }
 };
+function logPrismaError(ctx, errorType, errorCode, message, meta) {
+  const logLevel = typeof errorCode === "number" && errorCode >= 500 ? "error" : "warn";
+  this.logger[logLevel]("Database Error", {
+    type: errorType,
+    code: errorCode,
+    message,
+    requestId: ctx.id,
+    service: this.name,
+    action: ctx.action?.name,
+    meta,
+    caller: ctx.caller
+  });
+}
 var prismaErrorHandlers = {
-  P2002: (err, ctx) => {
-    throw new DBConstraintError(
-      "Unique constraint violation",
-      "UNIQUE_VIOLATION",
-      {
-        field: err.meta?.target ?? err.meta?.field_name,
-        constraint: "unique",
-        reason: `The value must be unique`,
-        prismaCode: err.code,
-        originalError: err.message,
-        requestId: ctx.id
-      }
-    );
+  P2002(err, ctx) {
+    const errorType = "UNIQUE_VIOLATION";
+    const message = "Unique constraint violation";
+    const data = {
+      field: err.meta?.target ?? err.meta?.field_name,
+      constraint: "unique",
+      reason: `The value must be unique`,
+      prismaCode: err.code,
+      originalError: err.message,
+      requestId: ctx.id
+    };
+    logPrismaError.bind(this)(ctx, errorType, 409, message, data);
+    throw new DBConstraintError(message, errorType, data);
   },
-  P2003: (err, ctx) => {
-    throw new DBConstraintError(
-      "Foreign key constraint failed",
-      "FOREIGN_KEY_VIOLATION",
-      {
-        field: err.meta?.field_name,
-        original: err.message,
-        ctx: ctx.id
-      }
-    );
+  P2003(err, ctx) {
+    const errorType = "FOREIGN_KEY_VIOLATION";
+    const message = "Foreign key constraint failed";
+    const data = {
+      field: err.meta?.field_name,
+      original: err.message,
+      ctx: ctx.id
+    };
+    logPrismaError.bind(this)(ctx, errorType, 409, message, data);
+    throw new DBConstraintError(message, errorType, data);
   },
-  P2014: (err, ctx) => {
+  P2014(err, ctx) {
     throw new DBConstraintError(
       "Invalid relation reference",
       "INVALID_RELATION",
@@ -423,21 +449,21 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2000: (err, ctx) => {
+  P2000(err, ctx) {
     throw new DBValidationError("Value too long for column", "VALUE_TOO_LONG", {
       column: err.meta?.column_name,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2001: (err, ctx) => {
+  P2001(err, ctx) {
     throw new DBNotFoundError("Record not found in where condition", {
       model: err.meta?.model_name,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2004: (err, ctx) => {
+  P2004(err, ctx) {
     throw new DBConstraintError(
       "Database constraint failed",
       "CONSTRAINT_FAILED",
@@ -448,28 +474,28 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2021: (err, ctx) => {
+  P2021(err, ctx) {
     throw new DBError("Table does not exist", 500, "TABLE_NOT_FOUND", {
       table: err.meta?.table,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2022: (err, ctx) => {
+  P2022(err, ctx) {
     throw new DBError("Column does not exist", 500, "COLUMN_NOT_FOUND", {
       column: err.meta?.column,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2006: (err, ctx) => {
+  P2006(err, ctx) {
     throw new DBValidationError("Invalid value for field", "INVALID_VALUE", {
       field: err.meta?.field_name,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2007: (err, ctx) => {
+  P2007(err, ctx) {
     throw new DBValidationError(
       "Data validation error",
       "DATA_VALIDATION_ERROR",
@@ -479,13 +505,13 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2008: (err, ctx) => {
+  P2008(err, ctx) {
     throw new DBError("Failed to parse the query", 400, "QUERY_PARSE_ERROR", {
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2009: (err, ctx) => {
+  P2009(err, ctx) {
     throw new DBError(
       "Failed to validate the query",
       400,
@@ -496,14 +522,14 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2010: (err, ctx) => {
+  P2010(err, ctx) {
     throw new DBError("Raw query failed", 500, "RAW_QUERY_FAILED", {
       code: err.meta?.code,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2011: (err, ctx) => {
+  P2011(err, ctx) {
     throw new DBConstraintError(
       "Null constraint violation",
       "NULL_CONSTRAINT_VIOLATION",
@@ -514,7 +540,7 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2012: (err, ctx) => {
+  P2012(err, ctx) {
     throw new DBValidationError(
       "Missing a required value",
       "MISSING_REQUIRED_VALUE",
@@ -525,7 +551,7 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2013: (err, ctx) => {
+  P2013(err, ctx) {
     throw new DBValidationError(
       "Missing the required argument",
       "MISSING_REQUIRED_ARGUMENT",
@@ -536,13 +562,13 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2015: (err, ctx) => {
+  P2015(err, ctx) {
     throw new DBNotFoundError("Related record not found", {
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2016: (err, ctx) => {
+  P2016(err, ctx) {
     throw new DBError(
       "Query interpretation error",
       400,
@@ -553,7 +579,7 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2017: (err, ctx) => {
+  P2017(err, ctx) {
     throw new DBConstraintError(
       "Records relation violation",
       "RELATION_VIOLATION",
@@ -564,25 +590,25 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2018: (err, ctx) => {
+  P2018(err, ctx) {
     throw new DBNotFoundError("Required connected records not found", {
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2019: (err, ctx) => {
+  P2019(err, ctx) {
     throw new DBValidationError("Input error", "INPUT_ERROR", {
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2020: (err, ctx) => {
+  P2020(err, ctx) {
     throw new DBValidationError("Value out of range", "VALUE_OUT_OF_RANGE", {
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2023: (err, ctx) => {
+  P2023(err, ctx) {
     throw new DBError(
       "Inconsistent column data",
       500,
@@ -593,13 +619,16 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2024: (err, ctx) => {
-    throw new DBTimeoutError("Operation timed out", {
+  P2024(err, ctx) {
+    const message = "Operation timed out";
+    const data = {
       original: err.message,
       ctx: ctx.id
-    });
+    };
+    logPrismaError.bind(this)(ctx, "DB_TIMEOUT", 504, message, data);
+    throw new DBTimeoutError(message, data);
   },
-  P2025: (err, ctx) => {
+  P2025(err, ctx) {
     throw new DBNotFoundError("Record not found for required operation", {
       operation: err.meta?.operation_name,
       model: err.meta?.model_name,
@@ -607,14 +636,14 @@ var prismaErrorHandlers = {
       ctx: ctx.id
     });
   },
-  P2026: (err, ctx) => {
+  P2026(err, ctx) {
     throw new DBError("Unsupported feature", 501, "UNSUPPORTED_FEATURE", {
       feature: err.meta?.feature,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2027: (err, ctx) => {
+  P2027(err, ctx) {
     throw new DBError(
       "Multiple database errors during execution",
       500,
@@ -625,13 +654,13 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2028: (err, ctx) => {
+  P2028(err, ctx) {
     throw new DBTransactionError("Transaction API error", {
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2030: (err, ctx) => {
+  P2030(err, ctx) {
     throw new DBError(
       "Cannot find fulltext index",
       500,
@@ -642,77 +671,130 @@ var prismaErrorHandlers = {
       }
     );
   },
-  P2033: (err, ctx) => {
+  P2033(err, ctx) {
     throw new DBValidationError("Number out of range", "NUMBER_OUT_OF_RANGE", {
       field: err.meta?.field_name,
       original: err.message,
       ctx: ctx.id
     });
   },
-  P2034: (err, ctx) => {
+  P2034(err, ctx) {
     throw new DBTransactionError("Transaction conflict", {
       original: err.message,
       ctx: ctx.id
     });
   }
 };
-var prismaErrorHandler = (err, info) => {
-  const { ctx, service, action } = info;
+function prismaErrorHandler(err, info) {
+  const { ctx, action } = info;
   if (err instanceof PrismaClientValidationError) {
-    throw new DBValidationError("Invalid input data", "INVALID_INPUT_DATA", {
+    const errorType = "INVALID_INPUT_DATA";
+    const message = "Invalid input data";
+    const data = {
       original: err.message,
       ctx: ctx.id,
-      service: service?.name,
+      service: this.name,
       action: action?.name
+    };
+    this.logger.warn("Database Validation Error", {
+      type: errorType,
+      message,
+      requestId: ctx.id,
+      service: this.name,
+      action: action?.name,
+      error: err.message
     });
+    throw new DBValidationError(message, errorType, data);
   }
   if (err instanceof PrismaClientInitializationError) {
-    throw new DBConnectionError("Database initialization failed", {
+    const message = "Database initialization failed";
+    const data = {
       original: err.message,
       ctx: ctx.id,
-      service: service?.name,
+      service: this.name,
       action: action?.name
+    };
+    this.logger.error("Database Connection Error", {
+      type: "DB_CONNECTION_ERROR",
+      message,
+      requestId: ctx.id,
+      service: this.name,
+      action: action?.name,
+      error: err.message
     });
+    throw new DBConnectionError(message, data);
   }
   if (err instanceof PrismaClientUnknownRequestError) {
-    throw new DBError("Unknown database error", 500, "DB_UNKNOWN_ERROR", {
+    const errorType = "DB_UNKNOWN_ERROR";
+    const message = "Unknown database error";
+    const data = {
       original: err.message,
       ctx: ctx.id,
-      service: service?.name,
+      service: this.name,
       action: action?.name
+    };
+    this.logger.error("Unknown Database Error", {
+      type: errorType,
+      message,
+      requestId: ctx.id,
+      service: this.name,
+      action: action?.name,
+      error: err.message,
+      stack: err.stack
     });
+    throw new DBError(message, 500, errorType, data);
   }
   if (err instanceof PrismaClientRustPanicError) {
-    throw new DBError("Database engine panic", 500, "DB_ENGINE_PANIC", {
+    const errorType = "DB_ENGINE_PANIC";
+    const message = "Database engine panic";
+    const data = {
       original: err.message,
       ctx: ctx.id,
-      service: service?.name,
+      service: this.name,
       action: action?.name
+    };
+    this.logger.fatal("Database Engine Panic", {
+      type: errorType,
+      message,
+      requestId: ctx.id,
+      service: this.name,
+      action: action?.name,
+      error: err.message,
+      stack: err.stack
     });
+    throw new DBError(message, 500, errorType, data);
   }
   if (err instanceof PrismaClientKnownRequestError) {
     const handler = prismaErrorHandlers[err.code];
     if (handler) {
-      return handler(err, ctx);
+      return handler.bind(this)(err, ctx);
     }
-    throw new DBError(
-      "Unknown database constraint error",
-      500,
-      "DB_CONSTRAINT_ERROR",
-      {
-        code: err.code,
-        meta: err.meta,
-        original: err.message,
-        ctx: ctx.id,
-        service: service?.name,
-        action: action?.name
-      }
-    );
+    const errorType = "DB_CONSTRAINT_ERROR";
+    const message = "Unknown database constraint error";
+    const data = {
+      code: err.code,
+      meta: err.meta,
+      original: err.message,
+      ctx: ctx.id,
+      service: this.name,
+      action: action?.name
+    };
+    this.logger.error("Unknown Database Constraint Error", {
+      type: errorType,
+      prismaCode: err.code,
+      message,
+      requestId: ctx.id,
+      service: this.name,
+      action: action?.name,
+      meta: err.meta,
+      error: err.message
+    });
+    throw new DBError(message, 500, errorType, data);
   }
   if (err instanceof Errors.MoleculerError) {
     throw err;
   }
-};
+}
 
 // src/middlewares/permissions.middleware.ts
 var permissionHandlers = {
@@ -1071,6 +1153,52 @@ function DatasourceMixin(datasourceConstructors = {}) {
   };
 }
 
+// src/utils/error-logger.ts
+function getErrorLogLevel(code) {
+  if (typeof code === "number") {
+    if (code >= 500) return "error";
+    if (code >= 400) return "warn";
+    return "info";
+  }
+  if (typeof code === "string") {
+    const criticalErrors = [
+      "DB_ENGINE_PANIC",
+      "SYSTEM_FAILURE",
+      "CRITICAL_ERROR"
+    ];
+    if (criticalErrors.includes(code)) return "fatal";
+    const systemErrors = [
+      "DB_CONNECTION_ERROR",
+      "INTERNAL_ERROR",
+      "TRANSACTION_ERROR"
+    ];
+    if (systemErrors.includes(code)) return "error";
+  }
+  return "warn";
+}
+function sanitizeErrorData(data) {
+  if (!data) return data;
+  const sensitiveKeys = [
+    "password",
+    "token",
+    "secret",
+    "apiKey",
+    "authorization"
+  ];
+  if (typeof data === "object") {
+    const sanitized = Array.isArray(data) ? [...data] : { ...data };
+    for (const key in sanitized) {
+      if (sensitiveKeys.some((k) => key.toLowerCase().includes(k.toLowerCase()))) {
+        sanitized[key] = "[REDACTED]";
+      } else if (typeof sanitized[key] === "object") {
+        sanitized[key] = sanitizeErrorData(sanitized[key]);
+      }
+    }
+    return sanitized;
+  }
+  return data;
+}
+
 // src/utils/index.ts
 function omit(obj, keys) {
   const result = { ...obj };
@@ -1852,18 +1980,51 @@ var configs = {
     PermissionsMiddleware,
     ContextHelpersMiddleware
   ],
-  errorHandler: (err, info) => {
-    prismaErrorHandler(err, info);
-    const { ctx, service, action } = info;
+  errorHandler(err, info) {
+    const { ctx, action } = info;
+    try {
+      prismaErrorHandler.bind(this)(err, info);
+    } catch (handledError) {
+      if (handledError instanceof Errors.MoleculerError) {
+        throw handledError;
+      }
+    }
+    const statusCode = err.code ?? err.statusCode ?? 500;
+    const errorType = err.type ?? "INTERNAL_ERROR";
+    const isSystemError = statusCode >= 500;
+    const logData = {
+      type: errorType,
+      message: err.message,
+      requestId: ctx.id,
+      service: this.name,
+      action: action?.name,
+      params: ctx.params,
+      caller: ctx.caller,
+      stack: isSystemError ? err.stack : void 0,
+      nodeID: ctx.nodeID,
+      level: ctx.level,
+      tracing: ctx.tracing
+    };
+    Object.keys(logData).forEach(
+      (key) => logData[key] === void 0 && delete logData[key]
+    );
+    if (isSystemError) {
+      this.logger.error("Unhandled Service Error", logData);
+    } else {
+      this.logger.warn("Service Error", logData);
+    }
+    if (err instanceof Errors.MoleculerError) {
+      throw err;
+    }
     throw new Errors.MoleculerError(
       err.message || "Internal server error",
-      500,
-      "INTERNAL_ERROR",
+      statusCode,
+      errorType,
       {
         original: err.message,
-        stack: err.stack,
+        stack: isSystemError ? err.stack : void 0,
         ctx: ctx.id,
-        service: service?.name,
+        service: this.name,
         action: action?.name
       }
     );
@@ -2444,4 +2605,4 @@ var retryExtension = {
   }
 };
 
-export { AbstractDatasource, AuthenticationError, CHANNELS, ContextHelpersMiddleware, CreateHealthCheckMiddleware, DBConnectionError, DBConstraintError, DBError, DBNotFoundError, DBTimeoutError, DBTransactionError, DBValidationError, DEFAULT_DATASOURCE_CACHE_TTL, DatasourceMixin, HEALTH_CHECK_DEFAULTS, INTEGRATION_CHANNELS, IntegrationCapability, IntegrationPlatform, IntegrationStatus, MemoizeMixin, MessageContentType, NAMESPACE, PERMISSIONS, PermissionError, PermissionsMiddleware, PrismaDatasource, PrismaPgDatasource, REDIS_URL, ROLE_PERMISSIONS, TenantError, UserRole, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, env_default as env, gatewayErrorHandler, isDev, isProd, isTest, moleculer_default as moleculer, nodeEnv, omit, prismaErrorHandler, retryExtension, softDeleteExtension };
+export { AbstractDatasource, AuthenticationError, CHANNELS, ContextHelpersMiddleware, CreateHealthCheckMiddleware, DBConnectionError, DBConstraintError, DBError, DBNotFoundError, DBTimeoutError, DBTransactionError, DBValidationError, DEFAULT_DATASOURCE_CACHE_TTL, DatasourceMixin, HEALTH_CHECK_DEFAULTS, INTEGRATION_CHANNELS, IntegrationCapability, IntegrationPlatform, IntegrationStatus, MemoizeMixin, MessageContentType, NAMESPACE, PERMISSIONS, PermissionError, PermissionsMiddleware, PrismaDatasource, PrismaPgDatasource, REDIS_URL, ROLE_PERMISSIONS, TenantError, UserRole, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, env_default as env, gatewayErrorHandler, getErrorLogLevel, isDev, isProd, isTest, moleculer_default as moleculer, nodeEnv, omit, prismaErrorHandler, retryExtension, sanitizeErrorData, softDeleteExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiliosai/sdk",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "license": "UNLICENSED",
   "main": "./dist/index.js",