@hiliosai/sdk 0.1.29 → 0.2.0

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;
@@ -900,4 +901,79 @@ declare function DatasourceMixin(datasourceConstructors?: DatasourceConstructorR
 
 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 const gatewayErrorHandler: (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 const prismaErrorHandler: (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 };

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,421 @@ var TenantError = class _TenantError extends Error {
   }
 };
 
+// src/errors/gateway.error.ts
+var gatewayErrorHandler = (req, res, error) => {
+  res.setHeader("Content-Type", "application/json; charset=utf-8");
+  const statusCode = error.code ?? 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] }
+    }
+  };
+  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);
+  }
+};
+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
+      }
+    );
+  },
+  P2003: (err, ctx) => {
+    throw new DBConstraintError(
+      "Foreign key constraint failed",
+      "FOREIGN_KEY_VIOLATION",
+      {
+        field: err.meta?.field_name,
+        original: err.message,
+        ctx: ctx.id
+      }
+    );
+  },
+  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) => {
+    throw new DBTimeoutError("Operation timed out", {
+      original: err.message,
+      ctx: ctx.id
+    });
+  },
+  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
+    });
+  }
+};
+var prismaErrorHandler = (err, info) => {
+  const { ctx, service, action } = info;
+  if (err instanceof PrismaClientValidationError) {
+    throw new DBValidationError("Invalid input data", "INVALID_INPUT_DATA", {
+      original: err.message,
+      ctx: ctx.id,
+      service: service?.name,
+      action: action?.name
+    });
+  }
+  if (err instanceof PrismaClientInitializationError) {
+    throw new DBConnectionError("Database initialization failed", {
+      original: err.message,
+      ctx: ctx.id,
+      service: service?.name,
+      action: action?.name
+    });
+  }
+  if (err instanceof PrismaClientUnknownRequestError) {
+    throw new DBError("Unknown database error", 500, "DB_UNKNOWN_ERROR", {
+      original: err.message,
+      ctx: ctx.id,
+      service: service?.name,
+      action: action?.name
+    });
+  }
+  if (err instanceof PrismaClientRustPanicError) {
+    throw new DBError("Database engine panic", 500, "DB_ENGINE_PANIC", {
+      original: err.message,
+      ctx: ctx.id,
+      service: service?.name,
+      action: action?.name
+    });
+  }
+  if (err instanceof PrismaClientKnownRequestError) {
+    const handler = prismaErrorHandlers[err.code];
+    if (handler) {
+      return handler(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
+      }
+    );
+  }
+  if (err instanceof Errors.MoleculerError) {
+    throw err;
+  }
+};
+
 // src/middlewares/permissions.middleware.ts
 var permissionHandlers = {
   [PERMISSIONS.AUTHENTICATED]: async (ctx) => !!ctx.meta.user?.id,
@@ -1099,8 +1516,7 @@ function defineIntegration(config) {
             credentials: integrationRaw.credentials
           };
           const createChannelAction = `v${this.version}.${this.name}.i_createChannel`;
-          await ctx.broker.call(createChannelAction, { integration });
-          payload.ackAck().then(
+          await ctx.broker.call(createChannelAction, { integration }).then(() => payload.ackAck()).then(
             () => ctx.broker.logger.debug("Integration registered", {
               name: this.name,
               version: this.version
@@ -1435,7 +1851,23 @@ var configs = {
     ChannelsMiddleware,
     PermissionsMiddleware,
     ContextHelpersMiddleware
-  ]
+  ],
+  errorHandler: (err, info) => {
+    prismaErrorHandler(err, info);
+    const { ctx, service, action } = info;
+    throw new Errors.MoleculerError(
+      err.message || "Internal server error",
+      500,
+      "INTERNAL_ERROR",
+      {
+        original: err.message,
+        stack: err.stack,
+        ctx: ctx.id,
+        service: service?.name,
+        action: action?.name
+      }
+    );
+  }
 };
 var moleculer_default = configs;
 
@@ -2012,4 +2444,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, isDev, isProd, isTest, moleculer_default as moleculer, nodeEnv, omit, prismaErrorHandler, retryExtension, softDeleteExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hiliosai/sdk",
-  "version": "0.1.29",
+  "version": "0.2.0",
   "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"
-}
+}