azurajs 3.0.1 → 3.0.2

package/src/utils/cookies/CookieManager.ts

@@ -0,0 +1,48 @@
+import type { CookieOptions } from "../../types/common.type.js";
+
+export function serializeCookie(
+  name: string,
+  value: string,
+  options: CookieOptions = {},
+): string {
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+
+  if (options.maxAge != null) {
+    cookie += `; Max-Age=${Math.floor(options.maxAge)}`;
+  }
+
+  if (options.expires) {
+    cookie += `; Expires=${options.expires.toUTCString()}`;
+  }
+
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+
+  cookie += `; Path=${options.path ?? "/"}`;
+
+  if (options.secure) {
+    cookie += "; Secure";
+  }
+
+  if (options.httpOnly !== false) {
+    cookie += "; HttpOnly";
+  }
+
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite}`;
+  }
+
+  return cookie;
+}
+
+export function clearCookieHeader(
+  name: string,
+  options: CookieOptions = {},
+): string {
+  return serializeCookie(name, "", {
+    ...options,
+    maxAge: 0,
+    expires: new Date(0),
+  });
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export { Logger } from "./Logger.js";
+export { HttpError } from "./HttpError.js";
+export { resolveIp } from "./IpResolver.js";
+export { parseQueryString, parseCookies, parseBody, parseUrl } from "./Parser.js";
+export { serializeCookie, clearCookieHeader } from "./cookies/CookieManager.js";
+export { DTOValidator } from "./validators/DTOValidator.js";
+export type { Schema, ValidationResult, ValidationError } from "./validators/DTOValidator.js";
+export { SchemaValidator } from "./validators/SchemaValidator.js";
+export type { ExternalSchema, SchemaValidationResult } from "./validators/SchemaValidator.js";

package/{dist/chunk-UWIFSGSQ.mjs → src/utils/validators/DTOValidator.ts}

@@ -1,141 +1,145 @@
-// src/utils/validators/DTOValidator.ts
-var DTOValidator = class {
-  static validate(data, schema) {
-    const errors = [];
-    if (data == null || typeof data !== "object") {
-      return {
-        valid: false,
-        errors: [{ field: "_root", message: "Request body must be an object" }]
-      };
-    }
-    for (const [field, rule] of Object.entries(schema)) {
-      const value = data[field];
-      if (rule.required && (value === void 0 || value === null || value === "")) {
-        errors.push({
-          field,
-          message: rule.message ?? `${field} is required`,
-          value
-        });
-        continue;
-      }
-      if (value === void 0 || value === null) continue;
-      if (rule.type) {
-        const actualType = Array.isArray(value) ? "array" : typeof value;
-        if (actualType !== rule.type) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must be of type ${rule.type}`,
-            value
-          });
-          continue;
-        }
-      }
-      if (rule.type === "string" || typeof value === "string") {
-        if (rule.min !== void 0 && value.length < rule.min) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must be at least ${rule.min} characters`,
-            value
-          });
-        }
-        if (rule.max !== void 0 && value.length > rule.max) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must be at most ${rule.max} characters`,
-            value
-          });
-        }
-        if (rule.pattern && !rule.pattern.test(value)) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} has invalid format`,
-            value
-          });
-        }
-      }
-      if (rule.type === "number" || typeof value === "number") {
-        if (rule.min !== void 0 && value < rule.min) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must be at least ${rule.min}`,
-            value
-          });
-        }
-        if (rule.max !== void 0 && value > rule.max) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must be at most ${rule.max}`,
-            value
-          });
-        }
-      }
-      if (rule.type === "array" && Array.isArray(value)) {
-        if (rule.min !== void 0 && value.length < rule.min) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must have at least ${rule.min} items`,
-            value
-          });
-        }
-        if (rule.max !== void 0 && value.length > rule.max) {
-          errors.push({
-            field,
-            message: rule.message ?? `${field} must have at most ${rule.max} items`,
-            value
-          });
-        }
-      }
-      if (rule.enum && !rule.enum.includes(value)) {
-        errors.push({
-          field,
-          message: rule.message ?? `${field} must be one of: ${rule.enum.join(", ")}`,
-          value
-        });
-      }
-      if (rule.custom) {
-        const customError = rule.custom(value);
-        if (customError) {
-          errors.push({ field, message: customError, value });
-        }
-      }
-    }
-    return {
-      valid: errors.length === 0,
-      errors,
-      data: errors.length === 0 ? data : void 0
-    };
-  }
-};
-
-// src/utils/validators/SchemaValidator.ts
-var SchemaValidator = class {
-  static validate(data, schema) {
-    if (typeof schema.safeParse === "function") {
-      const result = schema.safeParse(data);
-      if (result.success) {
-        return { valid: true, data: result.data };
-      }
-      return { valid: false, errors: result.error };
-    }
-    if (typeof schema.parse === "function") {
-      try {
-        const parsed = schema.parse(data);
-        return { valid: true, data: parsed };
-      } catch (err) {
-        return { valid: false, errors: err };
-      }
-    }
-    if (typeof schema.validate === "function") {
-      const result = schema.validate(data);
-      if (result.error) {
-        return { valid: false, errors: result.error };
-      }
-      return { valid: true, data: result.value };
-    }
-    return { valid: true, data };
-  }
-};
-
-export { DTOValidator, SchemaValidator };
-//# sourceMappingURL=chunk-UWIFSGSQ.mjs.map
-//# sourceMappingURL=chunk-UWIFSGSQ.mjs.map
+export interface ValidationError {
+  field: string;
+  message: string;
+  value?: any;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: ValidationError[];
+  data?: any;
+}
+
+type RuleType = "string" | "number" | "boolean" | "object" | "array";
+
+interface FieldRule {
+  type?: RuleType;
+  required?: boolean;
+  min?: number;
+  max?: number;
+  pattern?: RegExp;
+  enum?: any[];
+  custom?: (value: any) => string | null;
+  message?: string;
+}
+
+export type Schema = Record<string, FieldRule>;
+
+export class DTOValidator {
+  static validate(data: any, schema: Schema): ValidationResult {
+    const errors: ValidationError[] = [];
+
+    if (data == null || typeof data !== "object") {
+      return {
+        valid: false,
+        errors: [{ field: "_root", message: "Request body must be an object" }],
+      };
+    }
+
+    for (const [field, rule] of Object.entries(schema)) {
+      const value = data[field];
+
+      if (rule.required && (value === undefined || value === null || value === "")) {
+        errors.push({
+          field,
+          message: rule.message ?? `${field} is required`,
+          value,
+        });
+        continue;
+      }
+
+      if (value === undefined || value === null) continue;
+
+      if (rule.type) {
+        const actualType = Array.isArray(value) ? "array" : typeof value;
+        if (actualType !== rule.type) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be of type ${rule.type}`,
+            value,
+          });
+          continue;
+        }
+      }
+
+      if (rule.type === "string" || typeof value === "string") {
+        if (rule.min !== undefined && value.length < rule.min) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at least ${rule.min} characters`,
+            value,
+          });
+        }
+        if (rule.max !== undefined && value.length > rule.max) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at most ${rule.max} characters`,
+            value,
+          });
+        }
+        if (rule.pattern && !rule.pattern.test(value)) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} has invalid format`,
+            value,
+          });
+        }
+      }
+
+      if (rule.type === "number" || typeof value === "number") {
+        if (rule.min !== undefined && value < rule.min) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at least ${rule.min}`,
+            value,
+          });
+        }
+        if (rule.max !== undefined && value > rule.max) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must be at most ${rule.max}`,
+            value,
+          });
+        }
+      }
+
+      if (rule.type === "array" && Array.isArray(value)) {
+        if (rule.min !== undefined && value.length < rule.min) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must have at least ${rule.min} items`,
+            value,
+          });
+        }
+        if (rule.max !== undefined && value.length > rule.max) {
+          errors.push({
+            field,
+            message: rule.message ?? `${field} must have at most ${rule.max} items`,
+            value,
+          });
+        }
+      }
+
+      if (rule.enum && !rule.enum.includes(value)) {
+        errors.push({
+          field,
+          message: rule.message ?? `${field} must be one of: ${rule.enum.join(", ")}`,
+          value,
+        });
+      }
+
+      if (rule.custom) {
+        const customError = rule.custom(value);
+        if (customError) {
+          errors.push({ field, message: customError, value });
+        }
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      data: errors.length === 0 ? data : undefined,
+    };
+  }
+}

package/src/utils/validators/SchemaValidator.ts

@@ -0,0 +1,45 @@
+export interface ExternalSchema {
+  parse?: (data: any) => any;
+  safeParse?: (data: any) => { success: boolean; data?: any; error?: any };
+  validate?: (data: any) => { value?: any; error?: any };
+}
+
+export interface SchemaValidationResult {
+  valid: boolean;
+  data?: any;
+  errors?: any;
+}
+
+export class SchemaValidator {
+  static validate(data: any, schema: ExternalSchema): SchemaValidationResult {
+    // Zod-style schema
+    if (typeof schema.safeParse === "function") {
+      const result = schema.safeParse(data);
+      if (result.success) {
+        return { valid: true, data: result.data };
+      }
+      return { valid: false, errors: result.error };
+    }
+
+    // Zod parse (throws on error)
+    if (typeof schema.parse === "function") {
+      try {
+        const parsed = schema.parse(data);
+        return { valid: true, data: parsed };
+      } catch (err) {
+        return { valid: false, errors: err };
+      }
+    }
+
+    // Joi-style schema
+    if (typeof schema.validate === "function") {
+      const result = schema.validate(data);
+      if (result.error) {
+        return { valid: false, errors: result.error };
+      }
+      return { valid: true, data: result.value };
+    }
+
+    return { valid: true, data };
+  }
+}