@hiliosai/sdk 0.1.30 → 0.2.1

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import { Context, ServiceBroker, ServiceSchema as ServiceSchema$1, ServiceSettingSchema, Service, ActionSchema, ServiceEvents, ServiceHooks, Middleware, BrokerOptions } from 'moleculer';
+import { Context, ServiceBroker, ServiceSchema as ServiceSchema$1, ServiceSettingSchema, Service, ActionSchema, ServiceEvents, ServiceHooks, Middleware, BrokerOptions, Errors, BrokerErrorHandlerInfoAction } from 'moleculer';
 import env from '@ltv/env';
 export { default as env } from '@ltv/env';
 import { PrismaPg } from '@prisma/adapter-pg';
+import { IncomingMessage, ServerResponse } from 'http';
 
 interface Tenant {
     id: string;
@@ -898,6 +899,90 @@ 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>;
 
-export { AbstractDatasource, type ActionHandler, type ActionWithPermissions, type AppContext, type AppMeta, type AuditTrailExtension, type BaseDatasource, type BaseSpec, CHANNELS, type CarouselItem, type ChannelSendOptions, ContextHelpersMiddleware, CreateHealthCheckMiddleware, DEFAULT_DATASOURCE_CACHE_TTL, type DatasourceConstructorRegistry, type DatasourceContext, type DatasourceInstanceRegistry, type DatasourceInstanceTypes, DatasourceMixin, type Env, 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, 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, type TenantExtension, type User, UserRole, type WebhookEvent, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, isDev, isProd, isTest, configs as moleculer, nodeEnv, omit, retryExtension, softDeleteExtension };
+declare class PermissionError extends Error {
+    readonly code = "PERMISSION_DENIED";
+    readonly statusCode = 403;
+    readonly data: Record<string, unknown> | undefined;
+    constructor(message: string, data?: Record<string, unknown>);
+}
+
+declare class AuthenticationError extends Error {
+    readonly code = "AUTH_REQUIRED";
+    readonly statusCode = 401;
+    readonly data: Record<string, unknown> | undefined;
+    constructor(message: string, data?: Record<string, unknown>);
+}
+declare class TenantError extends Error {
+    readonly code = "TENANT_REQUIRED";
+    readonly statusCode = 401;
+    readonly data: Record<string, unknown> | undefined;
+    constructor(message: string, data?: Record<string, unknown>);
+}
+
+interface GatewayError extends Error {
+    code?: string | number;
+    statusCode?: number;
+    type?: string;
+    data?: any;
+}
+/**
+ * Custom error handler for the API Gateway
+ * Formats errors based on enterprise standards (Stripe, Google Cloud, AWS)
+ *
+ * Example response:
+ * {
+ *   "error": {
+ *     "code": "UNIQUE_VIOLATION",
+ *     "message": "Unique constraint violation",
+ *     "details": [{
+ *       "field": "email",
+ *       "constraint": "unique",
+ *       "reason": "The value must be unique"
+ *     }],
+ *     "timestamp": "2024-01-27T10:30:00Z",
+ *     "path": "/api/users",
+ *     "requestId": "req_abc123",
+ *     "help": "/docs/errors#unique-constraint"
+ *   }
+ * }
+ */
+declare function gatewayErrorHandler(this: Service, req: IncomingMessage & {
+    $ctx?: AppContext;
+    originalUrl?: string;
+}, res: ServerResponse, error: GatewayError): void;
+
+declare class DBError extends Errors.MoleculerError {
+    constructor(message: string, code: number, type?: string, data?: unknown);
+}
+declare class DBValidationError extends Errors.MoleculerError {
+    constructor(message: string, type?: string, data?: unknown, code?: number);
+}
+declare class DBConstraintError extends Errors.MoleculerError {
+    constructor(message: string, type?: string, data?: unknown);
+}
+declare class DBNotFoundError extends Errors.MoleculerError {
+    constructor(message: string, data?: unknown);
+}
+declare class DBConnectionError extends Errors.MoleculerError {
+    constructor(message: string, data?: unknown);
+}
+declare class DBTimeoutError extends Errors.MoleculerError {
+    constructor(message: string, data?: unknown);
+}
+declare class DBTransactionError extends Errors.MoleculerError {
+    constructor(message: string, data?: unknown);
+}
+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, getErrorLogLevel, isDev, isProd, isTest, configs as moleculer, nodeEnv, omit, prismaErrorHandler, retryExtension, sanitizeErrorData, softDeleteExtension };

package/dist/index.js

@@ -1,5 +1,7 @@
 import env4 from '@ltv/env';
 import http from 'http';
+import { PrismaClientValidationError, PrismaClientInitializationError, PrismaClientUnknownRequestError, PrismaClientRustPanicError, PrismaClientKnownRequestError } from '@prisma/client/runtime/client';
+import { Errors } from 'moleculer';
 import crypto from 'crypto';
 import os from 'os';
 import { Middleware } from '@moleculer/channels';
@@ -297,6 +299,503 @@ var TenantError = class _TenantError extends Error {
   }
 };
 
+// src/errors/gateway.error.ts
+function gatewayErrorHandler(req, res, error) {
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  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;
+  const path = req.originalUrl ?? req.url;
+  const docLinks = {
+    UNIQUE_VIOLATION: "/docs/errors#unique-constraint",
+    FOREIGN_KEY_VIOLATION: "/docs/errors#foreign-key",
+    VALIDATION_ERROR: "/docs/errors#validation",
+    NOT_FOUND: "/docs/errors#not-found",
+    MISSING_REQUIRED_VALUE: "/docs/errors#required-fields",
+    VALUE_TOO_LONG: "/docs/errors#field-length",
+    VALUE_OUT_OF_RANGE: "/docs/errors#value-range",
+    DB_CONNECTION_ERROR: "/docs/errors#connection",
+    DB_TIMEOUT: "/docs/errors#timeout",
+    TRANSACTION_ERROR: "/docs/errors#transaction"
+  };
+  const details = [];
+  if (error.data?.field) {
+    details.push({
+      field: error.data.field,
+      constraint: error.data.constraint,
+      reason: error.data.reason ?? error.message,
+      value: error.data.value
+    });
+  }
+  if (error.data?.errors && Array.isArray(error.data.errors)) {
+    error.data.errors.forEach((e) => {
+      details.push({
+        field: e.field ?? e.path,
+        reason: e.message ?? e.reason,
+        constraint: e.code ?? e.type
+      });
+    });
+  }
+  const errorCode = error.type ?? (error.name || "INTERNAL_ERROR");
+  const response = {
+    error: {
+      code: errorCode,
+      message: error.message || "An unexpected error occurred",
+      ...details.length > 0 && { details },
+      timestamp,
+      ...path && { path },
+      ...requestId && { requestId },
+      ...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);
+  }
+};
+var DBValidationError = class extends Errors.MoleculerError {
+  constructor(message, type = "VALIDATION_ERROR", data, code = 422) {
+    super(message, code, type, data);
+  }
+};
+var DBConstraintError = class extends Errors.MoleculerError {
+  constructor(message, type = "CONSTRAINT_ERROR", data) {
+    super(message, 409, type, data);
+  }
+};
+var DBNotFoundError = class extends Errors.MoleculerError {
+  constructor(message, data) {
+    super(message, 404, "NOT_FOUND", data);
+  }
+};
+var DBConnectionError = class extends Errors.MoleculerError {
+  constructor(message, data) {
+    super(message, 503, "DB_CONNECTION_ERROR", data);
+  }
+};
+var DBTimeoutError = class extends Errors.MoleculerError {
+  constructor(message, data) {
+    super(message, 504, "DB_TIMEOUT", data);
+  }
+};
+var DBTransactionError = class extends Errors.MoleculerError {
+  constructor(message, data) {
+    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) {
+    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) {
+    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) {
+    throw new DBConstraintError(
+      "Invalid relation reference",
+      "INVALID_RELATION",
+      {
+        relation: err.meta?.relation_name,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  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) {
+    throw new DBNotFoundError("Record not found in where condition", {
+      model: err.meta?.model_name,
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2004(err, ctx) {
+    throw new DBConstraintError(
+      "Database constraint failed",
+      "CONSTRAINT_FAILED",
+      {
+        constraint: err.meta?.constraint,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  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) {
+    throw new DBError("Column does not exist", 500, "COLUMN_NOT_FOUND", {
+      column: err.meta?.column,
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  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) {
+    throw new DBValidationError(
+      "Data validation error",
+      "DATA_VALIDATION_ERROR",
+      {
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2008(err, ctx) {
+    throw new DBError("Failed to parse the query", 400, "QUERY_PARSE_ERROR", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2009(err, ctx) {
+    throw new DBError(
+      "Failed to validate the query",
+      400,
+      "QUERY_VALIDATION_ERROR",
+      {
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  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) {
+    throw new DBConstraintError(
+      "Null constraint violation",
+      "NULL_CONSTRAINT_VIOLATION",
+      {
+        constraint: err.meta?.constraint,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2012(err, ctx) {
+    throw new DBValidationError(
+      "Missing a required value",
+      "MISSING_REQUIRED_VALUE",
+      {
+        field: err.meta?.field_name,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2013(err, ctx) {
+    throw new DBValidationError(
+      "Missing the required argument",
+      "MISSING_REQUIRED_ARGUMENT",
+      {
+        argument: err.meta?.argument_name,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2015(err, ctx) {
+    throw new DBNotFoundError("Related record not found", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2016(err, ctx) {
+    throw new DBError(
+      "Query interpretation error",
+      400,
+      "QUERY_INTERPRETATION_ERROR",
+      {
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2017(err, ctx) {
+    throw new DBConstraintError(
+      "Records relation violation",
+      "RELATION_VIOLATION",
+      {
+        relation: err.meta?.relation_name,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2018(err, ctx) {
+    throw new DBNotFoundError("Required connected records not found", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2019(err, ctx) {
+    throw new DBValidationError("Input error", "INPUT_ERROR", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2020(err, ctx) {
+    throw new DBValidationError("Value out of range", "VALUE_OUT_OF_RANGE", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2023(err, ctx) {
+    throw new DBError(
+      "Inconsistent column data",
+      500,
+      "INCONSISTENT_COLUMN_DATA",
+      {
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  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) {
+    throw new DBNotFoundError("Record not found for required operation", {
+      operation: err.meta?.operation_name,
+      model: err.meta?.model_name,
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2026(err, ctx) {
+    throw new DBError("Unsupported feature", 501, "UNSUPPORTED_FEATURE", {
+      feature: err.meta?.feature,
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2027(err, ctx) {
+    throw new DBError(
+      "Multiple database errors during execution",
+      500,
+      "MULTIPLE_DB_ERRORS",
+      {
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  P2028(err, ctx) {
+    throw new DBTransactionError("Transaction API error", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  P2030(err, ctx) {
+    throw new DBError(
+      "Cannot find fulltext index",
+      500,
+      "FULLTEXT_INDEX_NOT_FOUND",
+      {
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  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) {
+    throw new DBTransactionError("Transaction conflict", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  }
+};
+function prismaErrorHandler(err, info) {
+  const { ctx, action } = info;
+  if (err instanceof PrismaClientValidationError) {
+    const errorType = "INVALID_INPUT_DATA";
+    const message = "Invalid input data";
+    const data = {
+      original: err.message,
+      ctx: ctx.id,
+      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) {
+    const message = "Database initialization failed";
+    const data = {
+      original: err.message,
+      ctx: ctx.id,
+      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) {
+    const errorType = "DB_UNKNOWN_ERROR";
+    const message = "Unknown database error";
+    const data = {
+      original: err.message,
+      ctx: ctx.id,
+      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) {
+    const errorType = "DB_ENGINE_PANIC";
+    const message = "Database engine panic";
+    const data = {
+      original: err.message,
+      ctx: ctx.id,
+      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.bind(this)(err, ctx);
+    }
+    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 = {
   [PERMISSIONS.AUTHENTICATED]: async (ctx) => !!ctx.meta.user?.id,
@@ -654,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 };
@@ -1434,7 +1979,56 @@ var configs = {
     ChannelsMiddleware,
     PermissionsMiddleware,
     ContextHelpersMiddleware
-  ]
+  ],
+  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",
+      statusCode,
+      errorType,
+      {
+        original: err.message,
+        stack: isSystemError ? err.stack : void 0,
+        ctx: ctx.id,
+        service: this.name,
+        action: action?.name
+      }
+    );
+  }
 };
 var moleculer_default = configs;
 
@@ -2011,4 +2605,4 @@ var retryExtension = {
   }
 };
 
-export { AbstractDatasource, CHANNELS, ContextHelpersMiddleware, CreateHealthCheckMiddleware, DEFAULT_DATASOURCE_CACHE_TTL, DatasourceMixin, HEALTH_CHECK_DEFAULTS, INTEGRATION_CHANNELS, IntegrationCapability, IntegrationPlatform, IntegrationStatus, MemoizeMixin, MessageContentType, NAMESPACE, PERMISSIONS, PermissionsMiddleware, PrismaDatasource, PrismaPgDatasource, REDIS_URL, ROLE_PERMISSIONS, UserRole, createDatasourceMiddleware, createTenantExtension, defineIntegration, defineService, env_default as env, isDev, isProd, isTest, moleculer_default as moleculer, nodeEnv, omit, 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.1.30",
+  "version": "0.2.1",
   "type": "module",
   "license": "UNLICENSED",
   "main": "./dist/index.js",
@@ -29,8 +29,9 @@
     "@hiliosai/typescript": "workspace:*",
     "@pkg/dev-utils": "workspace:*",
     "@prisma/adapter-pg": "7.2.0",
+    "@prisma/client": "7.2.0",
     "bun-types": "latest",
     "nats": "2.29.3"
   },
   "prettier": "@hiliosai/prettier"
-}
+}