@gravito/core 2.0.6 → 3.0.0

package/dist/index.js

@@ -3300,7 +3300,7 @@ class Gravito {
 // package.json
 var package_default = {
   name: "@gravito/core",
-  version: "2.0.6",
+  version: "3.0.0",
   description: "",
   module: "./dist/index.js",
   main: "./dist/index.js",
@@ -5670,11 +5670,50 @@ class ConfigManager {
   }
 }
 
+// src/exceptions/GravitoException.ts
+class GravitoException extends Error {
+  status;
+  code;
+  i18nKey;
+  i18nParams;
+  constructor(status, code, options2 = {}) {
+    super(options2.message);
+    this.name = "GravitoException";
+    this.status = status;
+    this.cause = options2.cause;
+    this.code = code;
+    if (options2.i18nKey) {
+      this.i18nKey = options2.i18nKey;
+    }
+    if (options2.i18nParams) {
+      this.i18nParams = options2.i18nParams;
+    }
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  getLocalizedMessage(t) {
+    if (this.i18nKey) {
+      return t(this.i18nKey, this.i18nParams);
+    }
+    return this.message;
+  }
+}
+
+// src/exceptions/SystemException.ts
+class SystemException extends GravitoException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "SystemException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
 // src/exceptions/CircularDependencyException.ts
-class CircularDependencyException extends Error {
+class CircularDependencyException extends SystemException {
   constructor(key, stack) {
     const path2 = [...stack, key].map(String).join(" -> ");
-    super(`Circular dependency detected: ${path2}`);
+    super(500, "system.circular_dependency", {
+      message: `Circular dependency detected: ${path2}`
+    });
     this.name = "CircularDependencyException";
   }
 }
@@ -5840,33 +5879,6 @@ function detectRequestScopeLeaks(context) {
   };
 }
 
-// src/exceptions/GravitoException.ts
-class GravitoException extends Error {
-  status;
-  code;
-  i18nKey;
-  i18nParams;
-  constructor(status, code, options2 = {}) {
-    super(options2.message);
-    this.name = "GravitoException";
-    this.status = status;
-    this.cause = options2.cause;
-    this.code = code;
-    if (options2.i18nKey) {
-      this.i18nKey = options2.i18nKey;
-    }
-    if (options2.i18nParams) {
-      this.i18nParams = options2.i18nParams;
-    }
-  }
-  getLocalizedMessage(t) {
-    if (this.i18nKey) {
-      return t(this.i18nKey, this.i18nParams);
-    }
-    return this.message;
-  }
-}
-
 // src/exceptions/HttpException.ts
 class HttpException extends GravitoException {
   constructor(status, options2 = {}) {
@@ -5875,8 +5887,17 @@ class HttpException extends GravitoException {
   }
 }
 
+// src/exceptions/DomainException.ts
+class DomainException extends GravitoException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "DomainException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
 // src/exceptions/ValidationException.ts
-class ValidationException extends GravitoException {
+class ValidationException extends DomainException {
   errors;
   redirectTo;
   input;
@@ -5885,6 +5906,7 @@ class ValidationException extends GravitoException {
       message,
       i18nKey: "errors.validation.failed"
     });
+    this.name = "ValidationException";
     this.errors = errors;
   }
   withRedirect(url) {
@@ -10921,6 +10943,7 @@ class ModelNotFoundException extends GravitoException {
       i18nKey: "errors.model.not_found",
       i18nParams: { model, id: String(id ?? "") }
     });
+    this.name = "ModelNotFoundException";
     this.model = model;
     if (id !== undefined) {
       this.id = id;
@@ -11476,6 +11499,7 @@ class PlanetCore {
   deferredProviders = new Map;
   bootedProviders = new Set;
   isShuttingDown = false;
+  static GLOBAL_SHUTDOWN_TIMEOUT = 1e4;
   async initializeObservabilityAsync(obsConfig) {
     try {
       if (this.observabilityProvider && this.observabilityProvider !== this.observabilityProvider._isNoOp) {
@@ -11577,15 +11601,23 @@ class PlanetCore {
     }
     this.isShuttingDown = true;
     this.logger.debug("\uD83D\uDED1 Application shutdown started");
-    for (const provider of [...this.providers].reverse()) {
-      if (provider.onShutdown) {
-        try {
-          this.logger.debug(`  onShutdown: ${provider.constructor.name}`);
-          await provider.onShutdown(this);
-        } catch (error) {
-          this.logger.error(`Error during shutdown of ${provider.constructor.name}:`, error);
+    const shutdownSequence = async () => {
+      for (const provider of [...this.providers].reverse()) {
+        if (provider.onShutdown) {
+          try {
+            this.logger.debug(`  onShutdown: ${provider.constructor.name}`);
+            await provider.onShutdown(this);
+          } catch (error) {
+            this.logger.error(`Error during shutdown of ${provider.constructor.name}:`, error);
+          }
         }
       }
+    };
+    const globalDeadline = new Promise((_, reject) => setTimeout(() => reject(new Error("[PlanetCore] Global shutdown timeout exceeded (10s)")), PlanetCore.GLOBAL_SHUTDOWN_TIMEOUT));
+    try {
+      await Promise.race([shutdownSequence(), globalDeadline]);
+    } catch (err) {
+      this.logger.warn("[PlanetCore] Forced shutdown after global timeout:", err);
     }
     this.hooks.doAction("app:shutdown", this);
     this.logger.debug("\u2705 Application shutdown complete");
@@ -13190,22 +13222,98 @@ class QueueDashboard {
   }
 }
 // src/exceptions/AuthenticationException.ts
-class AuthenticationException extends GravitoException {
+class AuthenticationException extends DomainException {
   constructor(message = "Unauthenticated.") {
     super(401, "UNAUTHENTICATED", {
       message,
       i18nKey: "errors.authentication.unauthenticated"
     });
+    this.name = "AuthenticationException";
+  }
+}
+
+// src/exceptions/AuthException.ts
+class AuthException extends DomainException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "AuthException";
+    Object.setPrototypeOf(this, new.target.prototype);
   }
 }
 
 // src/exceptions/AuthorizationException.ts
-class AuthorizationException extends GravitoException {
+class AuthorizationException extends DomainException {
   constructor(message = "This action is unauthorized.") {
     super(403, "FORBIDDEN", {
       message,
       i18nKey: "errors.authorization.forbidden"
     });
+    this.name = "AuthorizationException";
+  }
+}
+
+// src/exceptions/InfrastructureException.ts
+class InfrastructureException extends GravitoException {
+  retryable;
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "InfrastructureException";
+    this.retryable = options2.retryable ?? false;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/CacheException.ts
+class CacheException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "CacheException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/ConfigurationException.ts
+class ConfigurationException extends SystemException {
+  constructor(message, options2 = {}) {
+    super(500, "system.configuration_error", { ...options2, message });
+    this.name = "ConfigurationException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/DatabaseException.ts
+class DatabaseException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "DatabaseException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/QueueException.ts
+class QueueException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "QueueException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/StorageException.ts
+class StorageException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "StorageException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+// src/exceptions/StreamException.ts
+class StreamException extends InfrastructureException {
+  constructor(status, code, options2 = {}) {
+    super(status, code, options2);
+    this.name = "StreamException";
+    Object.setPrototypeOf(this, new.target.prototype);
   }
 }
 // src/ServiceProvider.ts
@@ -13945,7 +14053,10 @@ export {
   ValidationException,
   VERSION,
   TestResponse,
+  SystemException,
+  StreamException,
   Str,
+  StorageException,
   StarvationProtectionStrategy,
   ServiceProvider,
   Router,
@@ -13961,6 +14072,7 @@ export {
   RateLimitStrategy,
   RadixRouter,
   RadixNode,
+  QueueException,
   QueueDepthStrategy,
   QueueDashboard,
   PriorityRebalanceStrategy,
@@ -13970,6 +14082,7 @@ export {
   OTelEventMetrics,
   NodeType,
   ModelNotFoundException,
+  InfrastructureException,
   IdempotencyCache,
   HttpTester,
   HttpException,
@@ -13988,18 +14101,22 @@ export {
   ErrorHandler,
   Encrypter,
   DumpDieError,
+  DomainException,
   DeadLetterQueueManager,
   DeadLetterQueue,
+  DatabaseException,
   DEFAULT_EVENT_OPTIONS,
   CookieJar,
   Container,
   ConsoleLogger,
+  ConfigurationException,
   ConfigManager,
   CompositeStrategy,
   CommandKernel,
   CircularDependencyException,
   CircuitBreakerState,
   CircuitBreaker,
+  CacheException,
   BunWebSocketHandler,
   BunRequest,
   BunNativeAdapter,
@@ -14009,8 +14126,9 @@ export {
   BackpressureManager,
   AuthorizationException,
   AuthenticationException,
+  AuthException,
   Arr,
   Application
 };
 
-//# debugId=B420456F9068F67364756E2164756E21
+//# debugId=182898C607162D4164756E2164756E21