npm - @guren/server - Versions diffs - 1.0.0-rc.9 → 1.1.0 - Mend

@guren/server 1.0.0-rc.9 → 1.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (70) hide show

package/dist/{Application-DtWDHXr1.d.ts → Application-BnsyCKXY.d.ts} +79 -8
package/dist/AuthManager-SfhCNkAU.d.ts +79 -0
package/dist/{BroadcastManager-AkIWUGJo.d.ts → BroadcastManager-CGWl9rUO.d.ts} +5 -0
package/dist/{ConsoleKernel-CqCVrdZs.d.ts → ConsoleKernel-BDtBETjm.d.ts} +1 -1
package/dist/{Gate-CNkBYf8m.d.ts → Gate-CynjZCtS.d.ts} +5 -0
package/dist/{I18nManager-Dtgzsf5n.d.ts → I18nManager-BiSoczfV.d.ts} +6 -1
package/dist/McpServiceProvider-JW6PDVMD.js +7 -0
package/dist/api-token-BSSCLlFW.d.ts +541 -0
package/dist/auth/index.d.ts +9 -327
package/dist/auth/index.js +59 -6684
package/dist/authorization/index.d.ts +2 -2
package/dist/authorization/index.js +19 -604
package/dist/broadcasting/index.d.ts +2 -2
package/dist/broadcasting/index.js +12 -895
package/dist/cache/index.js +8 -809
package/dist/chunk-2T6JN4VR.js +1563 -0
package/dist/chunk-44F7JQ7I.js +950 -0
package/dist/chunk-74HTZG3V.js +331 -0
package/dist/chunk-A3ISJVEV.js +598 -0
package/dist/chunk-CSDKWLFD.js +652 -0
package/dist/chunk-CSRQTEQA.js +839 -0
package/dist/chunk-DAQKYKLH.js +182 -0
package/dist/chunk-EDRGAM6G.js +647 -0
package/dist/chunk-EGU5KB7V.js +818 -0
package/dist/chunk-H32L2NE3.js +372 -0
package/dist/chunk-HKQSAFSN.js +837 -0
package/dist/chunk-IOTWFHZU.js +558 -0
package/dist/chunk-ONSDE37A.js +125 -0
package/dist/chunk-QH4NUKSV.js +255 -0
package/dist/chunk-QQKTH5KX.js +114 -0
package/dist/chunk-R2TCP7D7.js +409 -0
package/dist/chunk-SIP34GBE.js +380 -0
package/dist/chunk-THSX7OOR.js +454 -0
package/dist/chunk-UY3AZSYL.js +14 -0
package/dist/chunk-VT5KRDPH.js +134 -0
package/dist/chunk-WJJ5CTNI.js +907 -0
package/dist/chunk-WVY45EIW.js +359 -0
package/dist/chunk-ZRBLZY3M.js +462 -0
package/dist/client-CKXJLsTe.d.ts +232 -0
package/dist/email-verification-CAeArjui.d.ts +327 -0
package/dist/encryption/index.js +48 -556
package/dist/errors-JOOPDDQ6.js +34 -0
package/dist/events/index.js +14 -316
package/dist/health/index.js +12 -367
package/dist/i18n/index.d.ts +2 -2
package/dist/i18n/index.js +14 -583
package/dist/index.d.ts +37 -239
package/dist/index.js +2931 -19222
package/dist/lambda/index.d.ts +9 -7
package/dist/lambda/index.js +4 -9
package/dist/logging/index.js +12 -545
package/dist/mail/index.d.ts +29 -1
package/dist/mail/index.js +15 -684
package/dist/mcp/index.d.ts +7 -5
package/dist/mcp/index.js +5 -378
package/dist/notifications/index.d.ts +8 -6
package/dist/notifications/index.js +13 -730
package/dist/queue/index.d.ts +37 -7
package/dist/queue/index.js +22 -940
package/dist/redis/index.d.ts +366 -0
package/dist/redis/index.js +597 -0
package/dist/runtime/index.d.ts +8 -6
package/dist/runtime/index.js +26 -244
package/dist/scheduling/index.js +14 -822
package/dist/storage/index.d.ts +1 -0
package/dist/storage/index.js +6 -824
package/dist/vite/index.d.ts +2 -2
package/dist/vite/index.js +5 -1
package/package.json +15 -7
package/dist/api-token-JOif2CtG.d.ts +0 -1792

package/dist/chunk-THSX7OOR.js ADDED Viewed

@@ -0,0 +1,454 @@
+import {
+  HttpException
+} from "./chunk-DAQKYKLH.js";
+// src/errors/error-page.ts
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderErrorPage(statusCode, message) {
+  const title = STATUS_TITLES[statusCode] ?? "Error";
+  const description = escapeHtml(
+    message ?? STATUS_DESCRIPTIONS[statusCode] ?? "An unexpected error occurred."
+  );
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${statusCode} ${title}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: #fafaf9;
+      color: #1c1917;
+    }
+    .container { text-align: center; padding: 2rem; }
+    .status { font-size: 6rem; font-weight: 700; color: #d6d3d1; line-height: 1; }
+    .title { font-size: 1.5rem; font-weight: 600; margin-top: 1rem; }
+    .description { color: #78716c; margin-top: 0.5rem; max-width: 28rem; }
+    .home-link {
+      display: inline-block; margin-top: 2rem; padding: 0.625rem 1.5rem;
+      background: #1c1917; color: #fff; border-radius: 0.375rem;
+      text-decoration: none; font-size: 0.875rem; font-weight: 500;
+    }
+    .home-link:hover { background: #292524; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <div class="status">${statusCode}</div>
+    <h1 class="title">${title}</h1>
+    <p class="description">${description}</p>
+    <a href="/" class="home-link">Go Home</a>
+  </div>
+</body>
+</html>`;
+}
+var STATUS_TITLES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  408: "Request Timeout",
+  419: "Page Expired",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+var STATUS_DESCRIPTIONS = {
+  400: "The request could not be understood by the server.",
+  401: "You need to sign in to access this page.",
+  403: "You do not have permission to access this page.",
+  404: "The page you are looking for could not be found.",
+  405: "The request method is not supported for this page.",
+  419: "Your session has expired. Please refresh and try again.",
+  422: "The submitted data was invalid.",
+  429: "You are making too many requests. Please slow down.",
+  500: "Something went wrong on our end. Please try again later.",
+  502: "The server received an invalid response from an upstream server.",
+  503: "The service is temporarily unavailable. Please try again later.",
+  504: "The server did not receive a timely response from an upstream server."
+};
+// src/errors/ExceptionHandler.ts
+var ExceptionHandler = class {
+  /**
+   * Exception reporters.
+   */
+  reporters = [];
+  /**
+   * Exception renderers.
+   */
+  renderers = [];
+  /**
+   * Exception classes to not report.
+   */
+  dontReportClasses = [];
+  /**
+   * Handler options.
+   */
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * Register an exception reporter.
+   * Reporters are called for every exception (unless in dontReport list).
+   */
+  report(callback) {
+    this.reporters.push(callback);
+    return this;
+  }
+  /**
+   * Register a custom renderer for an exception type.
+   */
+  render(errorClass, renderer) {
+    this.renderers.push({
+      errorClass,
+      renderer
+    });
+    return this;
+  }
+  /**
+   * Add an exception class to the don't report list.
+   */
+  dontReport(errorClass) {
+    this.dontReportClasses.push(errorClass);
+    return this;
+  }
+  /**
+   * Check if debug mode is enabled.
+   */
+  shouldShowDetails() {
+    if (this.options.isDebug) {
+      return this.options.isDebug();
+    }
+    if (this.options.debug !== void 0) {
+      return this.options.debug;
+    }
+    return process.env.NODE_ENV !== "production";
+  }
+  /**
+   * Handle an exception.
+   */
+  async handle(error, ctx) {
+    await this.reportException(error);
+    return this.renderException(error, ctx);
+  }
+  /**
+   * Report an exception to all reporters.
+   */
+  async reportException(error) {
+    if (this.shouldNotReport(error)) {
+      return;
+    }
+    for (const reporter of this.reporters) {
+      try {
+        await reporter(error);
+      } catch (reporterError) {
+        console.error("Exception reporter failed:", reporterError);
+      }
+    }
+  }
+  /**
+   * Check if an exception should not be reported.
+   */
+  shouldNotReport(error) {
+    return this.dontReportClasses.some(
+      (errorClass) => this.matchesErrorClass(error, errorClass)
+    );
+  }
+  matchesErrorClass(error, errorClass) {
+    const errorClassName = errorClass.name;
+    const errorName = error.name;
+    const constructorName = error.constructor?.name;
+    return error instanceof errorClass || errorName === errorClassName || constructorName === errorClassName;
+  }
+  /**
+   * Render an exception to a response.
+   */
+  async renderException(error, ctx) {
+    for (const { errorClass, renderer } of this.renderers) {
+      if (this.matchesErrorClass(error, errorClass)) {
+        return renderer(error, ctx);
+      }
+    }
+    return this.renderDefaultException(error, ctx);
+  }
+  /**
+   * Default exception rendering.
+   */
+  renderDefaultException(error, ctx) {
+    const debug = this.shouldShowDetails();
+    if (HttpException.isHttpException(error)) {
+      const { status, body: body2 } = error.toResponse(debug);
+      if (this.wantsHtmlResponse(ctx) && !debug) {
+        return ctx.html(renderErrorPage(status, body2.message), status);
+      }
+      return ctx.json(body2, status);
+    }
+    const statusCode = "statusCode" in error && typeof error.statusCode === "number" ? error.statusCode : 500;
+    const body = {
+      message: statusCode < 500 || debug ? error.message : "Internal Server Error"
+    };
+    if (debug) {
+      body.exception = error.name;
+      body.stack = error.stack;
+    }
+    if (this.wantsHtmlResponse(ctx) && !debug) {
+      return ctx.html(renderErrorPage(statusCode, body.message), statusCode);
+    }
+    return ctx.json(body, statusCode);
+  }
+  /**
+   * Determine whether the request expects an HTML response.
+   * Returns false for Inertia, XHR, and JSON API requests so they
+   * continue to receive JSON error payloads.
+   */
+  wantsHtmlResponse(ctx) {
+    if (!ctx?.req?.header) return false;
+    const accept = ctx.req.header("accept") ?? "";
+    const isJsonRequest = accept.includes("application/json") || ctx.req.header("x-requested-with") === "XMLHttpRequest" || ctx.req.header("x-inertia") === "true";
+    return !isJsonRequest && accept.includes("text/html");
+  }
+  /**
+   * Create middleware for exception handling.
+   */
+  middleware() {
+    return async (ctx, next) => {
+      try {
+        return await next();
+      } catch (error) {
+        const response = error instanceof Error ? await this.handle(error, ctx) : await this.handle(new Error(String(error)), ctx);
+        ctx.res = response;
+        return response;
+      }
+    };
+  }
+};
+function createExceptionHandler(options) {
+  return new ExceptionHandler(options);
+}
+var globalExceptionHandler = null;
+function setExceptionHandler(handler) {
+  globalExceptionHandler = handler;
+}
+function getExceptionHandler() {
+  if (!globalExceptionHandler) {
+    throw new Error(
+      "ExceptionHandler not initialized. Call setExceptionHandler() first."
+    );
+  }
+  return globalExceptionHandler;
+}
+function abort(statusCode, message, errors) {
+  throw new HttpException(statusCode, message ?? "Error", errors);
+}
+function abortIf(condition, statusCode, message) {
+  if (condition) {
+    abort(statusCode, message);
+  }
+}
+function abortUnless(condition, statusCode, message) {
+  if (!condition) {
+    abort(statusCode, message);
+  }
+}
+// src/errors/exceptions/ValidationException.ts
+var ValidationException = class _ValidationException extends HttpException {
+  constructor(errors, message = "The given data was invalid.") {
+    super(422, message, errors);
+    this.name = "ValidationException";
+  }
+  /**
+   * Create from Zod error.
+   */
+  static fromZodError(zodError) {
+    const errors = {};
+    for (const issue of zodError.issues) {
+      const path = issue.path.join(".");
+      if (!errors[path]) {
+        errors[path] = [];
+      }
+      errors[path].push(issue.message);
+    }
+    return new _ValidationException(errors);
+  }
+  /**
+   * Get errors for a specific field.
+   */
+  getFieldErrors(field) {
+    return this.errors?.[field] ?? [];
+  }
+  /**
+   * Check if a field has errors.
+   */
+  hasFieldError(field) {
+    return (this.errors?.[field]?.length ?? 0) > 0;
+  }
+  /**
+   * Get the first error for a field.
+   */
+  getFirstError(field) {
+    return this.errors?.[field]?.[0] ?? null;
+  }
+  /**
+   * Get all error messages as a flat array.
+   */
+  getAllMessages() {
+    if (!this.errors) return [];
+    return Object.values(this.errors).flat();
+  }
+  /**
+   * Create a ValidationException from a plain messages object.
+   *
+   * Useful for business-logic validation (e.g. duplicate email checks)
+   * where Zod is not involved.
+   *
+   * @example
+   * ```typescript
+   * throw ValidationException.withMessages({ email: 'Email already registered' })
+   * throw ValidationException.withMessages({ email: ['Must be unique', 'Must be corporate'] })
+   * ```
+   */
+  static withMessages(messages) {
+    const errors = {};
+    for (const [key, value] of Object.entries(messages)) {
+      errors[key] = Array.isArray(value) ? value : [value];
+    }
+    return new _ValidationException(errors);
+  }
+};
+// src/errors/exceptions/AuthorizationException.ts
+var AuthorizationException = class _AuthorizationException extends HttpException {
+  /**
+   * The action that was attempted.
+   */
+  action;
+  /**
+   * The resource that was being accessed.
+   */
+  resource;
+  constructor(message = "This action is unauthorized.", action, resource) {
+    super(403, message);
+    this.name = "AuthorizationException";
+    this.action = action;
+    this.resource = resource;
+  }
+  /**
+   * Create exception for a specific action and resource.
+   */
+  static forAction(action, resource) {
+    const message = resource ? `You are not authorized to ${action} this ${resource}.` : `You are not authorized to ${action}.`;
+    return new _AuthorizationException(message, action, resource);
+  }
+  /**
+   * Deny access to a resource.
+   */
+  static deny(resource) {
+    const message = resource ? `Access to ${resource} denied.` : "Access denied.";
+    return new _AuthorizationException(message, "access", resource);
+  }
+};
+// src/errors/exceptions/NotFoundHttpException.ts
+var NotFoundHttpException = class _NotFoundHttpException extends HttpException {
+  /**
+   * The type of resource that was not found.
+   */
+  resourceType;
+  /**
+   * The ID of the resource that was not found.
+   */
+  resourceId;
+  constructor(message = "Not Found", resourceType, resourceId) {
+    super(404, message);
+    this.name = "NotFoundHttpException";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+  /**
+   * Create exception for a model not found.
+   */
+  static forModel(model, id) {
+    return new _NotFoundHttpException(
+      `${model} with ID ${id} not found.`,
+      model,
+      id
+    );
+  }
+  /**
+   * Create exception for a route not found.
+   */
+  static forRoute(path) {
+    return new _NotFoundHttpException(`Route ${path} not found.`, "Route");
+  }
+  /**
+   * Create exception for a resource not found.
+   */
+  static forResource(resource) {
+    return new _NotFoundHttpException(`${resource} not found.`, resource);
+  }
+};
+// src/errors/exceptions/MethodNotAllowedException.ts
+var MethodNotAllowedException = class _MethodNotAllowedException extends HttpException {
+  /**
+   * The HTTP method that was attempted.
+   */
+  method;
+  /**
+   * The allowed HTTP methods.
+   */
+  allowedMethods;
+  constructor(method, allowedMethods, message) {
+    const defaultMessage = method ? `Method ${method} is not allowed.` : "Method Not Allowed";
+    super(405, message ?? defaultMessage);
+    this.name = "MethodNotAllowedException";
+    this.method = method;
+    this.allowedMethods = allowedMethods;
+  }
+  /**
+   * Get the Allow header value.
+   */
+  getAllowHeader() {
+    return this.allowedMethods?.join(", ") ?? "";
+  }
+  /**
+   * Create exception with method details.
+   */
+  static forMethod(method, allowedMethods) {
+    return new _MethodNotAllowedException(
+      method,
+      allowedMethods,
+      `Method ${method} not allowed. Allowed methods: ${allowedMethods.join(", ")}`
+    );
+  }
+};
+export {
+  ValidationException,
+  renderErrorPage,
+  ExceptionHandler,
+  createExceptionHandler,
+  setExceptionHandler,
+  getExceptionHandler,
+  abort,
+  abortIf,
+  abortUnless,
+  AuthorizationException,
+  NotFoundHttpException,
+  MethodNotAllowedException
+};

package/dist/chunk-UY3AZSYL.js ADDED Viewed

@@ -0,0 +1,14 @@
+// src/redis/client.ts
+import Redis from "ioredis";
+function createRedisClient(options = {}) {
+  const { url, ...redisOptions } = options;
+  if (url) {
+    return new Redis(url, redisOptions);
+  }
+  return new Redis(redisOptions);
+}
+export {
+  Redis,
+  createRedisClient
+};

package/dist/chunk-VT5KRDPH.js ADDED Viewed

@@ -0,0 +1,134 @@
+// src/container/ServiceProvider.ts
+var ServiceProvider = class {
+  constructor(container) {
+    this.container = container;
+  }
+  /**
+   * Whether this provider should be deferred.
+   * Deferred providers are only loaded when one of their provided services is requested.
+   */
+  static deferred = false;
+  /**
+   * The services provided by this provider (for deferred loading).
+   */
+  static provides = [];
+  /**
+   * Get the services provided by the provider.
+   */
+  provides() {
+    return this.constructor.provides;
+  }
+  /**
+   * Check if this provider is deferred.
+   */
+  isDeferred() {
+    return this.constructor.deferred;
+  }
+};
+var ProviderManager = class {
+  constructor(container) {
+    this.container = container;
+  }
+  providers = [];
+  registered = /* @__PURE__ */ new Set();
+  booted = /* @__PURE__ */ new Set();
+  deferredProviders = /* @__PURE__ */ new Map();
+  allBooted = false;
+  /**
+   * Register a provider.
+   */
+  register(providerOrClass) {
+    if (this.allBooted) {
+      const name = providerOrClass instanceof ServiceProvider ? providerOrClass.constructor.name : providerOrClass.name;
+      throw new Error(
+        `Cannot register provider "${name}" after bootAll() has been called. Register all providers before booting the application.`
+      );
+    }
+    const provider = providerOrClass instanceof ServiceProvider ? providerOrClass : new providerOrClass(this.container);
+    if (provider.isDeferred()) {
+      for (const service of provider.provides()) {
+        this.deferredProviders.set(service, provider);
+      }
+    } else {
+      this.providers.push(provider);
+    }
+    return this;
+  }
+  /**
+   * Register multiple providers.
+   */
+  registerMany(providers) {
+    for (const provider of providers) {
+      this.register(provider);
+    }
+    return this;
+  }
+  /**
+   * Register all non-deferred providers.
+   */
+  async registerAll() {
+    for (const provider of this.providers) {
+      if (!this.registered.has(provider)) {
+        await provider.register();
+        this.registered.add(provider);
+      }
+    }
+  }
+  /**
+   * Boot all registered providers.
+   */
+  async bootAll() {
+    for (const provider of this.providers) {
+      if (!this.booted.has(provider) && this.registered.has(provider)) {
+        await provider.boot?.();
+        this.booted.add(provider);
+      }
+    }
+    this.allBooted = true;
+    if (this.deferredProviders.size > 0) {
+      this.container.deferredProviderLoader = (service) => this.loadDeferredProvider(service);
+    }
+  }
+  /**
+   * Load a deferred provider for a service.
+   */
+  async loadDeferredProvider(service) {
+    const provider = this.deferredProviders.get(service);
+    if (!provider) return;
+    if (!this.registered.has(provider)) {
+      await provider.register();
+      this.registered.add(provider);
+      this.providers.push(provider);
+    }
+    if (!this.booted.has(provider)) {
+      await provider.boot?.();
+      this.booted.add(provider);
+    }
+    for (const providedService of provider.provides()) {
+      this.deferredProviders.delete(providedService);
+    }
+  }
+  /**
+   * Check if a service is provided by a deferred provider.
+   */
+  isDeferredService(service) {
+    return this.deferredProviders.has(service);
+  }
+  /**
+   * Get all registered providers.
+   */
+  getProviders() {
+    return [...this.providers];
+  }
+  /**
+   * Get all deferred services.
+   */
+  getDeferredServices() {
+    return Array.from(this.deferredProviders.keys());
+  }
+};
+export {
+  ServiceProvider,
+  ProviderManager
+};