canxjs 1.0.0 → 1.1.0

package/dist/index.js

@@ -22777,14 +22777,14 @@ var require_messages = __commonJS((exports) => {
     length: 4
   };
 
-  class DatabaseError extends Error {
+  class DatabaseError2 extends Error {
     constructor(message, length, name) {
       super(message);
       this.length = length;
       this.name = name;
     }
   }
-  exports.DatabaseError = DatabaseError;
+  exports.DatabaseError = DatabaseError2;
 
   class CopyDataMessage {
     constructor(length, chunk) {
@@ -25326,7 +25326,7 @@ var require_lib5 = __commonJS((exports, module) => {
   var utils = require_utils();
   var Pool = require_pg_pool();
   var TypeOverrides = require_type_overrides();
-  var { DatabaseError } = require_dist();
+  var { DatabaseError: DatabaseError2 } = require_dist();
   var { escapeIdentifier, escapeLiteral } = require_utils();
   var poolFactory = (Client2) => {
     return class BoundPool extends Pool {
@@ -25343,7 +25343,7 @@ var require_lib5 = __commonJS((exports, module) => {
     this._pools = [];
     this.Connection = Connection;
     this.types = require_pg_types();
-    this.DatabaseError = DatabaseError;
+    this.DatabaseError = DatabaseError2;
     this.TypeOverrides = TypeOverrides;
     this.escapeIdentifier = escapeIdentifier;
     this.escapeLiteral = escapeLiteral;
@@ -25387,11 +25387,11 @@ __export(exports_esm, {
   Result: () => Result,
   Query: () => Query,
   Pool: () => Pool,
-  DatabaseError: () => DatabaseError,
+  DatabaseError: () => DatabaseError2,
   Connection: () => Connection,
   Client: () => Client
 });
-var import_lib, Client, Pool, Connection, types, Query, DatabaseError, escapeIdentifier, escapeLiteral, Result, TypeOverrides, defaults, esm_default;
+var import_lib, Client, Pool, Connection, types, Query, DatabaseError2, escapeIdentifier, escapeLiteral, Result, TypeOverrides, defaults, esm_default;
 var init_esm = __esm(() => {
   import_lib = __toESM(require_lib5(), 1);
   Client = import_lib.default.Client;
@@ -25399,7 +25399,7 @@ var init_esm = __esm(() => {
   Connection = import_lib.default.Connection;
   types = import_lib.default.types;
   Query = import_lib.default.Query;
-  DatabaseError = import_lib.default.DatabaseError;
+  DatabaseError2 = import_lib.default.DatabaseError;
   escapeIdentifier = import_lib.default.escapeIdentifier;
   escapeLiteral = import_lib.default.escapeLiteral;
   Result = import_lib.default.Result;
@@ -26337,6 +26337,547 @@ var compress = () => {
 function createMiddlewarePipeline() {
   return new MiddlewarePipeline;
 }
+// src/middlewares/SecurityMiddleware.ts
+function security(config = {}) {
+  return async (req, res, next) => {
+    if (config.xssProtection !== false) {
+      res.header("X-XSS-Protection", "1; mode=block");
+    }
+    if (config.contentTypeOptions !== false) {
+      res.header("X-Content-Type-Options", "nosniff");
+    }
+    if (config.frameOptions) {
+      res.header("X-Frame-Options", config.frameOptions);
+    } else if (config.frameOptions !== undefined) {
+      res.header("X-Frame-Options", config.frameOptions);
+    } else {
+      res.header("X-Frame-Options", "SAMEORIGIN");
+    }
+    if (config.hsts) {
+      const maxAge = typeof config.hsts === "object" ? config.hsts.maxAge : 31536000;
+      const includeSubDomains = typeof config.hsts === "object" && config.hsts.includeSubDomains ? "; includeSubDomains" : "";
+      res.header("Strict-Transport-Security", `max-age=${maxAge}${includeSubDomains}`);
+    }
+    if (config.contentSecurityPolicy) {
+      res.header("Content-Security-Policy", config.contentSecurityPolicy);
+    }
+    if (config.referrerPolicy) {
+      res.header("Referrer-Policy", config.referrerPolicy);
+    }
+    return next();
+  };
+}
+// src/middlewares/RateLimitMiddleware.ts
+class MemoryStore {
+  hits = new Map;
+  increment(key, windowMs) {
+    const now = Date.now();
+    let record = this.hits.get(key);
+    if (!record || record.resetTime <= now) {
+      record = { count: 1, resetTime: now + windowMs };
+    } else {
+      record.count++;
+    }
+    this.hits.set(key, record);
+    return record;
+  }
+}
+function rateLimit2(config) {
+  const store = new MemoryStore;
+  const {
+    windowMs = 60000,
+    max = 100,
+    message = "Too many requests, please try again later.",
+    statusCode = 429,
+    keyGenerator = (req) => req.header("x-forwarded-for") || req.header("cf-connecting-ip") || "unknown-ip"
+  } = config;
+  return async (req, res, next) => {
+    const key = keyGenerator(req);
+    const { count, resetTime } = store.increment(key, windowMs);
+    const remaining = Math.max(0, max - count);
+    const resetDate = new Date(resetTime);
+    res.header("X-RateLimit-Limit", String(max));
+    res.header("X-RateLimit-Remaining", String(remaining));
+    res.header("X-RateLimit-Reset", String(Math.ceil(resetTime / 1000)));
+    if (count > max) {
+      if (typeof message === "object") {
+        return res.status(statusCode).json(message);
+      }
+      return res.status(statusCode).text(String(message));
+    }
+    return next();
+  };
+}
+// src/utils/ErrorHandler.ts
+class CanxError extends Error {
+  code;
+  statusCode;
+  details;
+  timestamp;
+  constructor(message, code = "CANX_ERROR", statusCode = 500, details) {
+    super(message);
+    this.name = "CanxError";
+    this.code = code;
+    this.statusCode = statusCode;
+    this.details = details;
+    this.timestamp = new Date;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      details: this.details,
+      timestamp: this.timestamp.toISOString()
+    };
+  }
+}
+
+class ValidationError extends CanxError {
+  errors;
+  constructor(errors, message = "Validation failed") {
+    const errorMap = errors instanceof Map ? errors : new Map(Object.entries(errors));
+    super(message, "VALIDATION_ERROR", 422, { errors: Object.fromEntries(errorMap) });
+    this.name = "ValidationError";
+    this.errors = errorMap;
+  }
+}
+
+class NotFoundError extends CanxError {
+  constructor(resource = "Resource", id) {
+    const message = id ? `${resource} with ID ${id} not found` : `${resource} not found`;
+    super(message, "NOT_FOUND", 404, { resource, id });
+    this.name = "NotFoundError";
+  }
+}
+
+class AuthenticationError extends CanxError {
+  constructor(message = "Authentication required") {
+    super(message, "AUTHENTICATION_ERROR", 401);
+    this.name = "AuthenticationError";
+  }
+}
+
+class AuthorizationError extends CanxError {
+  constructor(message = "You do not have permission to access this resource") {
+    super(message, "AUTHORIZATION_ERROR", 403);
+    this.name = "AuthorizationError";
+  }
+}
+
+class ConflictError extends CanxError {
+  constructor(message = "Resource conflict", resource) {
+    super(message, "CONFLICT_ERROR", 409, { resource });
+    this.name = "ConflictError";
+  }
+}
+
+class RateLimitError extends CanxError {
+  retryAfter;
+  constructor(retryAfter = 60, message = "Too many requests") {
+    super(message, "RATE_LIMIT_ERROR", 429, { retryAfter });
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+}
+
+class BadRequestError extends CanxError {
+  constructor(message = "Bad request") {
+    super(message, "BAD_REQUEST", 400);
+    this.name = "BadRequestError";
+  }
+}
+
+class DatabaseError extends CanxError {
+  constructor(message = "Database error", originalError) {
+    super(message, "DATABASE_ERROR", 500, {
+      originalMessage: originalError?.message,
+      stack: originalError?.stack
+    });
+    this.name = "DatabaseError";
+  }
+}
+
+class ServiceUnavailableError extends CanxError {
+  constructor(service, message) {
+    super(message || `Service ${service} is currently unavailable`, "SERVICE_UNAVAILABLE", 503, { service });
+    this.name = "ServiceUnavailableError";
+  }
+}
+function errorHandler(options = {}) {
+  const { showStack = true, logErrors = true } = options;
+  return async (req, res, next) => {
+    try {
+      return await next();
+    } catch (error) {
+      if (logErrors) {
+        console.error(`[CanxJS Error] ${req.method} ${req.path}:`, error);
+      }
+      if (options.onError) {
+        options.onError(error, req);
+      }
+      const isJson = req.header("accept")?.includes("application/json") ?? true;
+      let statusCode = 500;
+      let errorResponse = {
+        code: "INTERNAL_ERROR",
+        message: "Internal server error"
+      };
+      if (error instanceof CanxError) {
+        statusCode = error.statusCode;
+        errorResponse = {
+          code: error.code,
+          message: error.message,
+          ...error.details && { details: error.details }
+        };
+      } else {
+        const unknownError = error;
+        errorResponse.message = showStack ? unknownError.message : "Internal server error";
+      }
+      if (showStack && error instanceof Error) {
+        errorResponse.stack = error.stack;
+      }
+      if (isJson) {
+        return res.status(statusCode).json({ error: errorResponse });
+      } else {
+        const html = `
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Error ${statusCode}</title>
+              <style>
+                body { font-family: system-ui, sans-serif; padding: 2rem; max-width: 800px; margin: 0 auto; }
+                .error-box { background: #fee2e2; color: #991b1b; padding: 1.5rem; border-radius: 0.5rem; }
+                pre { background: #f1f5f9; padding: 1rem; overflow-x: auto; border-radius: 0.5rem; }
+              </style>
+            </head>
+            <body>
+              <h1>Error ${statusCode}</h1>
+              <div class="error-box">
+                <p><strong>${errorResponse.code}</strong>: ${errorResponse.message}</p>
+              </div>
+              ${showStack && errorResponse.stack ? `<pre>${errorResponse.stack}</pre>` : ""}
+            </body>
+          </html>
+        `;
+        return res.status(statusCode).html(html);
+      }
+    }
+  };
+}
+function asyncHandler(fn) {
+  return async (req, res) => {
+    try {
+      return await fn(req, res);
+    } catch (error) {
+      if (error instanceof CanxError) {
+        return res.status(error.statusCode).json(error.toJSON());
+      }
+      throw error;
+    }
+  };
+}
+function assertFound(value, resource = "Resource", id) {
+  if (value === null || value === undefined) {
+    throw new NotFoundError(resource, id);
+  }
+  return value;
+}
+function assertAuthenticated(user) {
+  if (!user) {
+    throw new AuthenticationError;
+  }
+  return user;
+}
+function assertAuthorized(condition, message) {
+  if (!condition) {
+    throw new AuthorizationError(message);
+  }
+}
+function assertValid(valid, errors) {
+  if (!valid) {
+    throw new ValidationError(errors || new Map);
+  }
+}
+var errors = {
+  CanxError,
+  ValidationError,
+  NotFoundError,
+  AuthenticationError,
+  AuthorizationError,
+  ConflictError,
+  RateLimitError,
+  BadRequestError,
+  DatabaseError,
+  ServiceUnavailableError
+};
+var ErrorHandler_default = {
+  ...errors,
+  errorHandler,
+  asyncHandler,
+  assertFound,
+  assertAuthenticated,
+  assertAuthorized,
+  assertValid
+};
+
+// src/middlewares/ValidationMiddleware.ts
+function validateSchema(schema, target = "body") {
+  return async (req, res, next) => {
+    let data;
+    if (target === "body") {
+      data = await req.body();
+    } else if (target === "query") {
+      data = req.query;
+    } else {
+      data = req.params;
+    }
+    try {
+      const validated = schema.parse(data);
+      req.validatedData = validated;
+      return next();
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return res.status(422).json({
+          error: {
+            code: "VALIDATION_ERROR",
+            message: "Validation failed",
+            details: Object.fromEntries(error.errors)
+          }
+        });
+      }
+      throw error;
+    }
+  };
+}
+// src/schema/Schema.ts
+class Schema {
+  _output;
+  _input;
+  description;
+  isOptional = false;
+  safeParse(value) {
+    try {
+      const data = this.parse(value);
+      return { success: true, data };
+    } catch (error) {
+      if (error instanceof ValidationError) {
+        return { success: false, error };
+      }
+      throw error;
+    }
+  }
+  optional() {
+    const newSchema = Object.create(this);
+    newSchema.isOptional = true;
+    return newSchema;
+  }
+  describe(description) {
+    this.description = description;
+    return this;
+  }
+}
+
+class StringSchema extends Schema {
+  checks = [];
+  constructor() {
+    super();
+  }
+  min(length, message) {
+    this.checks.push((v) => v.length >= length ? null : message || `String must contain at least ${length} character(s)`);
+    return this;
+  }
+  max(length, message) {
+    this.checks.push((v) => v.length <= length ? null : message || `String must contain at most ${length} character(s)`);
+    return this;
+  }
+  email(message) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    this.checks.push((v) => emailRegex.test(v) ? null : message || "Invalid email address");
+    return this;
+  }
+  parse(value) {
+    if (this.isOptional && (value === undefined || value === null)) {
+      return value;
+    }
+    if (typeof value !== "string") {
+      throw new ValidationError({ _errors: ["Expected string, received " + typeof value] });
+    }
+    for (const check of this.checks) {
+      const error = check(value);
+      if (error) {
+        throw new ValidationError({ _errors: [error] });
+      }
+    }
+    return value;
+  }
+  getJsonSchema() {
+    return {
+      type: "string",
+      description: this.description
+    };
+  }
+}
+
+class NumberSchema extends Schema {
+  checks = [];
+  min(min, message) {
+    this.checks.push((v) => v >= min ? null : message || `Number must be greater than or equal to ${min}`);
+    return this;
+  }
+  max(max, message) {
+    this.checks.push((v) => v <= max ? null : message || `Number must be less than or equal to ${max}`);
+    return this;
+  }
+  parse(value) {
+    if (this.isOptional && (value === undefined || value === null)) {
+      return value;
+    }
+    if (typeof value !== "number" || isNaN(value)) {
+      if (typeof value === "string" && !isNaN(parseFloat(value))) {
+        const num = parseFloat(value);
+        return this.validateChecks(num);
+      }
+      throw new ValidationError({ _errors: ["Expected number, received " + typeof value] });
+    }
+    return this.validateChecks(value);
+  }
+  validateChecks(value) {
+    for (const check of this.checks) {
+      const error = check(value);
+      if (error) {
+        throw new ValidationError({ _errors: [error] });
+      }
+    }
+    return value;
+  }
+  getJsonSchema() {
+    return {
+      type: "number",
+      description: this.description
+    };
+  }
+}
+
+class BooleanSchema extends Schema {
+  parse(value) {
+    if (this.isOptional && (value === undefined || value === null)) {
+      return value;
+    }
+    if (typeof value === "boolean")
+      return value;
+    if (value === "true")
+      return true;
+    if (value === "false")
+      return false;
+    throw new ValidationError({ _errors: ["Expected boolean, received " + typeof value] });
+  }
+  getJsonSchema() {
+    return {
+      type: "boolean",
+      description: this.description
+    };
+  }
+}
+
+class ObjectSchema extends Schema {
+  shape;
+  constructor(shape) {
+    super();
+    this.shape = shape;
+  }
+  parse(value) {
+    if (this.isOptional && (value === undefined || value === null)) {
+      return value;
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new ValidationError({ _errors: ["Expected object, received " + typeof value] });
+    }
+    const result = {};
+    const errors2 = new Map;
+    for (const [key, schema] of Object.entries(this.shape)) {
+      try {
+        result[key] = schema.parse(value[key]);
+      } catch (error) {
+        if (error instanceof ValidationError) {
+          const fieldErrors = error.errors.get("_errors") || [];
+          if (error.errors.size > 0 && !error.errors.has("_errors")) {
+            error.errors.forEach((msgs, path) => {
+              errors2.set(`${key}.${path}`, msgs);
+            });
+          } else {
+            errors2.set(key, fieldErrors);
+          }
+        } else {
+          errors2.set(key, ["Invalid value"]);
+        }
+      }
+    }
+    if (errors2.size > 0) {
+      throw new ValidationError(errors2);
+    }
+    return result;
+  }
+  getJsonSchema() {
+    const properties = {};
+    const required = [];
+    for (const [key, schema] of Object.entries(this.shape)) {
+      properties[key] = schema.getJsonSchema();
+      if (!schema.isOptional) {
+        if (!schema.isOptional) {
+          required.push(key);
+        }
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      required: required.length > 0 ? required : undefined,
+      description: this.description
+    };
+  }
+}
+
+class ArraySchema extends Schema {
+  element;
+  constructor(element) {
+    super();
+    this.element = element;
+  }
+  parse(value) {
+    if (this.isOptional && (value === undefined || value === null)) {
+      return value;
+    }
+    if (!Array.isArray(value)) {
+      throw new ValidationError({ _errors: ["Expected array, received " + typeof value] });
+    }
+    return value.map((item, index) => {
+      try {
+        return this.element.parse(item);
+      } catch (error) {
+        if (error instanceof ValidationError) {
+          throw new ValidationError({ [index]: error.errors.get("_errors") || ["Invalid Item"] });
+        }
+        throw error;
+      }
+    });
+  }
+  getJsonSchema() {
+    return {
+      type: "array",
+      items: this.element.getJsonSchema(),
+      description: this.description
+    };
+  }
+}
+var z = {
+  string: () => new StringSchema,
+  number: () => new NumberSchema,
+  boolean: () => new BooleanSchema,
+  object: (shape) => new ObjectSchema(shape),
+  array: (element) => new ArraySchema(element)
+};
 // src/mvc/Controller.ts
 var controllerMeta = new WeakMap;
 function getControllerMeta(target) {
@@ -27600,7 +28141,7 @@ class TableBuilder {
 ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`;
   }
 }
-var Schema = {
+var Schema2 = {
   async create(table, callback) {
     const builder = new TableBuilder(table);
     callback(builder);
@@ -27631,9 +28172,9 @@ var Schema = {
 class Migrator {
   migrations = [];
   async ensureTable() {
-    const exists = await Schema.hasTable("migrations");
+    const exists = await Schema2.hasTable("migrations");
     if (!exists) {
-      await Schema.create("migrations", (table) => {
+      await Schema2.create("migrations", (table) => {
         table.id();
         table.string("name").unique();
         table.integer("batch");
@@ -29494,7 +30035,7 @@ function parseRule(rule) {
   return { name, param };
 }
 function validate(data, schema) {
-  const errors = new Map;
+  const errors2 = new Map;
   const validData = {};
   for (const [field, rules] of Object.entries(schema)) {
     const value = data[field];
@@ -29530,12 +30071,12 @@ function validate(data, schema) {
       }
     }
     if (fieldErrors.length > 0) {
-      errors.set(field, fieldErrors);
+      errors2.set(field, fieldErrors);
     } else if (value !== undefined) {
       validData[field] = value;
     }
   }
-  return { valid: errors.size === 0, errors, data: validData };
+  return { valid: errors2.size === 0, errors: errors2, data: validData };
 }
 function validateAsync(data, schema) {
   return Promise.resolve(validate(data, schema));
@@ -29764,193 +30305,6 @@ class RequestParser {
 function parseRequest(raw) {
   return new RequestParser(raw);
 }
-// src/utils/ErrorHandler.ts
-class CanxError extends Error {
-  code;
-  statusCode;
-  details;
-  timestamp;
-  constructor(message, code = "CANX_ERROR", statusCode = 500, details) {
-    super(message);
-    this.name = "CanxError";
-    this.code = code;
-    this.statusCode = statusCode;
-    this.details = details;
-    this.timestamp = new Date;
-    Error.captureStackTrace?.(this, this.constructor);
-  }
-  toJSON() {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      statusCode: this.statusCode,
-      details: this.details,
-      timestamp: this.timestamp.toISOString()
-    };
-  }
-}
-
-class ValidationError extends CanxError {
-  errors;
-  constructor(errors, message = "Validation failed") {
-    const errorMap = errors instanceof Map ? errors : new Map(Object.entries(errors));
-    super(message, "VALIDATION_ERROR", 422, { errors: Object.fromEntries(errorMap) });
-    this.name = "ValidationError";
-    this.errors = errorMap;
-  }
-}
-
-class NotFoundError extends CanxError {
-  constructor(resource = "Resource", id) {
-    const message = id ? `${resource} with ID ${id} not found` : `${resource} not found`;
-    super(message, "NOT_FOUND", 404, { resource, id });
-    this.name = "NotFoundError";
-  }
-}
-
-class AuthenticationError extends CanxError {
-  constructor(message = "Authentication required") {
-    super(message, "AUTHENTICATION_ERROR", 401);
-    this.name = "AuthenticationError";
-  }
-}
-
-class AuthorizationError extends CanxError {
-  constructor(message = "You do not have permission to access this resource") {
-    super(message, "AUTHORIZATION_ERROR", 403);
-    this.name = "AuthorizationError";
-  }
-}
-
-class ConflictError extends CanxError {
-  constructor(message = "Resource conflict", resource) {
-    super(message, "CONFLICT_ERROR", 409, { resource });
-    this.name = "ConflictError";
-  }
-}
-
-class RateLimitError extends CanxError {
-  retryAfter;
-  constructor(retryAfter = 60, message = "Too many requests") {
-    super(message, "RATE_LIMIT_ERROR", 429, { retryAfter });
-    this.name = "RateLimitError";
-    this.retryAfter = retryAfter;
-  }
-}
-
-class BadRequestError extends CanxError {
-  constructor(message = "Bad request") {
-    super(message, "BAD_REQUEST", 400);
-    this.name = "BadRequestError";
-  }
-}
-
-class DatabaseError2 extends CanxError {
-  constructor(message = "Database error", originalError) {
-    super(message, "DATABASE_ERROR", 500, {
-      originalMessage: originalError?.message,
-      stack: originalError?.stack
-    });
-    this.name = "DatabaseError";
-  }
-}
-
-class ServiceUnavailableError extends CanxError {
-  constructor(service, message) {
-    super(message || `Service ${service} is currently unavailable`, "SERVICE_UNAVAILABLE", 503, { service });
-    this.name = "ServiceUnavailableError";
-  }
-}
-function errorHandler(options = {}) {
-  const { showStack = true, logErrors = true } = options;
-  return async (req, res, next) => {
-    try {
-      return await next();
-    } catch (error) {
-      if (logErrors) {
-        console.error(`[CanxJS Error] ${req.method} ${req.path}:`, error);
-      }
-      if (options.onError) {
-        options.onError(error, req);
-      }
-      if (error instanceof CanxError) {
-        const response2 = {
-          error: {
-            code: error.code,
-            message: error.message,
-            ...error.details && { details: error.details },
-            ...showStack && { stack: error.stack }
-          }
-        };
-        return res.status(error.statusCode).json(response2);
-      }
-      const unknownError = error;
-      return res.status(500).json({
-        error: {
-          code: "INTERNAL_ERROR",
-          message: showStack ? unknownError.message : "Internal server error",
-          ...showStack && { stack: unknownError.stack }
-        }
-      });
-    }
-  };
-}
-function asyncHandler(fn) {
-  return async (req, res) => {
-    try {
-      return await fn(req, res);
-    } catch (error) {
-      if (error instanceof CanxError) {
-        return res.status(error.statusCode).json(error.toJSON());
-      }
-      throw error;
-    }
-  };
-}
-function assertFound(value, resource = "Resource", id) {
-  if (value === null || value === undefined) {
-    throw new NotFoundError(resource, id);
-  }
-  return value;
-}
-function assertAuthenticated(user) {
-  if (!user) {
-    throw new AuthenticationError;
-  }
-  return user;
-}
-function assertAuthorized(condition, message) {
-  if (!condition) {
-    throw new AuthorizationError(message);
-  }
-}
-function assertValid(valid, errors) {
-  if (!valid) {
-    throw new ValidationError(errors || new Map);
-  }
-}
-var errors = {
-  CanxError,
-  ValidationError,
-  NotFoundError,
-  AuthenticationError,
-  AuthorizationError,
-  ConflictError,
-  RateLimitError,
-  BadRequestError,
-  DatabaseError: DatabaseError2,
-  ServiceUnavailableError
-};
-var ErrorHandler_default = {
-  ...errors,
-  errorHandler,
-  asyncHandler,
-  assertFound,
-  assertAuthenticated,
-  assertAuthorized,
-  assertValid
-};
 // src/utils/Logger.ts
 var LOG_LEVELS = {
   debug: 0,
@@ -30870,8 +31224,13 @@ class Canx {
     return this;
   }
   async listen(port, callback) {
-    if (port)
+    if (typeof port === "function") {
+      callback = port;
+      port = undefined;
+    }
+    if (port && typeof port === "number") {
       this.config.port = port;
+    }
     for (const plugin of this.plugins) {
       await plugin.install(this);
     }
@@ -30919,9 +31278,11 @@ function createApp(config) {
   return new Canx(config);
 }
 export {
+  z,
   ws,
   verifyPassword,
   verifyJWT,
+  validateSchema,
   validateAsync,
   validate,
   useI18n,
@@ -30935,6 +31296,7 @@ export {
   sendMail,
   factory as seederFactory,
   seeder,
+  security,
   roles,
   response,
   resolve,
@@ -30942,6 +31304,7 @@ export {
   renderPage,
   render,
   redisCheck,
+  rateLimit2 as rateLimitMiddleware,
   rateLimit,
   randomUuid,
   randomString,
@@ -31031,13 +31394,14 @@ export {
   assertFound,
   assertAuthorized,
   assertAuthenticated,
+  Schema as ZSchema,
   WebSocketServer,
   ValidationError,
   TestClient,
   ServiceUnavailableError,
   Server,
   ScopedContainer,
-  Schema,
+  Schema2 as Schema,
   S3Driver,
   Router,
   ResponseBuilder,
@@ -31068,7 +31432,7 @@ export {
   EventServiceProvider,
   EventEmitter,
   Delete,
-  DatabaseError2 as DatabaseError,
+  DatabaseError,
   Controller,
   Container,
   ConflictError,