3a-ecommerce-utils 1.0.0

package/dist/validation/server.d.mts

@@ -0,0 +1,50 @@
+import { Request, Response, NextFunction } from 'express';
+export { y as batchValidate, h as isValidCouponCode, i as isValidEmail, p as isValidObjectId, a as isValidPassword, d as isValidPhone, f as isValidPostalCode, t as isValidSku, r as isValidUrl, j as validateCouponCode, w as validateDate, x as validateDateRange, n as validateDiscountPercentage, v as validateEmail, c as validateName, q as validateObjectId, o as validatePagination, b as validatePassword, e as validatePhone, g as validatePostalCode, k as validatePrice, l as validateQuantity, m as validateRating, u as validateSku, s as validateUrl } from '../client-DYGi_pyp.mjs';
+import { LogLevel } from '@e-commerce/types';
+
+/**
+ * Server-side Logger with file system support
+ * For frontend apps, use logger.client.ts instead
+ */
+
+interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    data?: any;
+    context?: string;
+}
+declare class Logger {
+    private static logs;
+    private static maxLogs;
+    private static enableConsole;
+    private static enableFile;
+    private static logFilePath;
+    private static logLevel;
+    static configure(options: {
+        maxLogs?: number;
+        enableConsole?: boolean;
+        enableFile?: boolean;
+        logFilePath?: string;
+        logLevel?: LogLevel | string;
+    }): void;
+    private static shouldLog;
+    private static addLog;
+    private static format;
+    static debug(message: string, data?: any, context?: string): void;
+    static info(message: string, data?: any, context?: string): void;
+    static warn(message: string, data?: any, context?: string): void;
+    static error(message: string, error?: any, context?: string): void;
+    private static log;
+    static getLogs(level?: LogLevel): LogEntry[];
+    static clearLogs(): void;
+}
+
+/**
+ * Server-side only validation utilities
+ * These require Express and should only be used in backend services
+ */
+
+declare const validate: (req: Request, res: Response, next: NextFunction) => void;
+
+export { Logger, validate };

package/dist/validation/server.d.ts

@@ -0,0 +1,50 @@
+import { Request, Response, NextFunction } from 'express';
+export { y as batchValidate, h as isValidCouponCode, i as isValidEmail, p as isValidObjectId, a as isValidPassword, d as isValidPhone, f as isValidPostalCode, t as isValidSku, r as isValidUrl, j as validateCouponCode, w as validateDate, x as validateDateRange, n as validateDiscountPercentage, v as validateEmail, c as validateName, q as validateObjectId, o as validatePagination, b as validatePassword, e as validatePhone, g as validatePostalCode, k as validatePrice, l as validateQuantity, m as validateRating, u as validateSku, s as validateUrl } from '../client-DYGi_pyp.js';
+import { LogLevel } from '@e-commerce/types';
+
+/**
+ * Server-side Logger with file system support
+ * For frontend apps, use logger.client.ts instead
+ */
+
+interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+    data?: any;
+    context?: string;
+}
+declare class Logger {
+    private static logs;
+    private static maxLogs;
+    private static enableConsole;
+    private static enableFile;
+    private static logFilePath;
+    private static logLevel;
+    static configure(options: {
+        maxLogs?: number;
+        enableConsole?: boolean;
+        enableFile?: boolean;
+        logFilePath?: string;
+        logLevel?: LogLevel | string;
+    }): void;
+    private static shouldLog;
+    private static addLog;
+    private static format;
+    static debug(message: string, data?: any, context?: string): void;
+    static info(message: string, data?: any, context?: string): void;
+    static warn(message: string, data?: any, context?: string): void;
+    static error(message: string, error?: any, context?: string): void;
+    private static log;
+    static getLogs(level?: LogLevel): LogEntry[];
+    static clearLogs(): void;
+}
+
+/**
+ * Server-side only validation utilities
+ * These require Express and should only be used in backend services
+ */
+
+declare const validate: (req: Request, res: Response, next: NextFunction) => void;
+
+export { Logger, validate };

package/dist/validation/server.js

@@ -0,0 +1,518 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/validation/server.ts
+var server_exports = {};
+__export(server_exports, {
+  Logger: () => Logger,
+  batchValidate: () => batchValidate,
+  isValidCouponCode: () => isValidCouponCode,
+  isValidEmail: () => isValidEmail,
+  isValidObjectId: () => isValidObjectId,
+  isValidPassword: () => isValidPassword,
+  isValidPhone: () => isValidPhone,
+  isValidPostalCode: () => isValidPostalCode,
+  isValidSku: () => isValidSku,
+  isValidUrl: () => isValidUrl,
+  validate: () => validate,
+  validateCouponCode: () => validateCouponCode,
+  validateDate: () => validateDate,
+  validateDateRange: () => validateDateRange,
+  validateDiscountPercentage: () => validateDiscountPercentage,
+  validateEmail: () => validateEmail,
+  validateName: () => validateName,
+  validateObjectId: () => validateObjectId,
+  validatePagination: () => validatePagination,
+  validatePassword: () => validatePassword,
+  validatePhone: () => validatePhone,
+  validatePostalCode: () => validatePostalCode,
+  validatePrice: () => validatePrice,
+  validateQuantity: () => validateQuantity,
+  validateRating: () => validateRating,
+  validateSku: () => validateSku,
+  validateUrl: () => validateUrl
+});
+module.exports = __toCommonJS(server_exports);
+var import_express_validator = require("express-validator");
+
+// src/constants/index.ts
+var PORT_CONFIG = {
+  AUTH_SERVICE: 3011,
+  CATEGORY_SERVICE: 3012,
+  COUPON_SERVICE: 3013,
+  PRODUCT_SERVICE: 3014,
+  ORDER_SERVICE: 3015,
+  GRAPHQL_GATEWAY: 4e3,
+  STOREFRONT_APP: 3e3,
+  ADMIN_APP: 3001,
+  SELLER_APP: 3002,
+  SHELL_APP: 3003
+};
+var SERVICE_URLS = {
+  AUTH_SERVICE: `http://localhost:${PORT_CONFIG.AUTH_SERVICE}`,
+  CATEGORY_SERVICE: `http://localhost:${PORT_CONFIG.CATEGORY_SERVICE}`,
+  COUPON_SERVICE: `http://localhost:${PORT_CONFIG.COUPON_SERVICE}`,
+  PRODUCT_SERVICE: `http://localhost:${PORT_CONFIG.PRODUCT_SERVICE}`,
+  ORDER_SERVICE: `http://localhost:${PORT_CONFIG.ORDER_SERVICE}`,
+  GRAPHQL_GATEWAY: `http://localhost:${PORT_CONFIG.GRAPHQL_GATEWAY}/graphql`,
+  AUTH_API: `http://localhost:${PORT_CONFIG.AUTH_SERVICE}/api`,
+  CATEGORY_API: `http://localhost:${PORT_CONFIG.CATEGORY_SERVICE}/api`,
+  COUPON_API: `http://localhost:${PORT_CONFIG.COUPON_SERVICE}/api`,
+  PRODUCT_API: `http://localhost:${PORT_CONFIG.PRODUCT_SERVICE}/api`,
+  ORDER_API: `http://localhost:${PORT_CONFIG.ORDER_SERVICE}/api`
+};
+var DEFAULT_CORS_ORIGINS = [
+  "http://localhost:3000",
+  "http://localhost:3001",
+  "http://localhost:3002",
+  "http://localhost:3003"
+];
+var JWT_CONFIG = {
+  ACCESS_TOKEN_EXPIRY: "1h",
+  REFRESH_TOKEN_EXPIRY: "7d",
+  PASSWORD_MIN_LENGTH: 8,
+  PASSWORD_PATTERN: /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/
+};
+var PRODUCT_CONFIG = {
+  MIN_PRICE: 0,
+  MAX_PRICE: 999999.99,
+  MIN_STOCK: 0,
+  MAX_RATING: 5,
+  MIN_RATING: 0,
+  DEFAULT_RATING: 0,
+  MAX_IMAGE_SIZE: 5 * 1024 * 1024,
+  // 5MB
+  ALLOWED_IMAGE_TYPES: ["image/jpeg", "image/png", "image/webp"]
+};
+var TIMEOUT_CONFIG = {
+  API_REQUEST: 3e4,
+  // 30 seconds
+  DATABASE: 1e4,
+  // 10 seconds
+  GRAPHQL: 15e3
+  // 15 seconds
+};
+var REGEX_PATTERNS = {
+  EMAIL: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+  PHONE: /^[\d\-\s()]{10,}$/,
+  POSTAL_CODE: /^\d{5,6}$/,
+  COUPON_CODE: /^[A-Z0-9]{6,20}$/,
+  PRODUCT_SKU: /^[A-Z0-9\-]{3,20}$/,
+  URL: /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w.-]*)*\/?$/
+};
+var ENV_PRESETS = {
+  DEVELOPMENT: {
+    corsOrigins: DEFAULT_CORS_ORIGINS,
+    logLevel: "debug",
+    apiTimeout: TIMEOUT_CONFIG.API_REQUEST
+  },
+  PRODUCTION: {
+    corsOrigins: ["https://ecommerce.example.com", "https://admin.ecommerce.example.com"],
+    logLevel: "info",
+    apiTimeout: TIMEOUT_CONFIG.API_REQUEST
+  },
+  TESTING: {
+    corsOrigins: ["http://localhost:*"],
+    logLevel: "error",
+    apiTimeout: TIMEOUT_CONFIG.API_REQUEST
+  }
+};
+
+// src/validation/client.ts
+var isValidEmail = (email) => {
+  return REGEX_PATTERNS.EMAIL.test(email);
+};
+var validateEmail = (email) => {
+  if (!email || email.trim() === "") {
+    return { valid: false, error: "Email is required" };
+  }
+  if (!isValidEmail(email)) {
+    return { valid: false, error: "Invalid email format" };
+  }
+  if (email.length > 255) {
+    return { valid: false, error: "Email is too long" };
+  }
+  return { valid: true };
+};
+var isValidPassword = (password) => {
+  return JWT_CONFIG.PASSWORD_PATTERN.test(password);
+};
+var validatePassword = (password) => {
+  if (!password) {
+    return { valid: false, error: "Password is required" };
+  }
+  if (password.length < JWT_CONFIG.PASSWORD_MIN_LENGTH) {
+    return {
+      valid: false,
+      error: `Password must be at least ${JWT_CONFIG.PASSWORD_MIN_LENGTH} characters`
+    };
+  }
+  if (!isValidPassword(password)) {
+    return {
+      valid: false,
+      error: "Password must contain uppercase, lowercase, number, and special character (@$!%*?&)"
+    };
+  }
+  return { valid: true };
+};
+var validateName = (name) => {
+  if (!name || name.trim() === "") {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length < 2) {
+    return { valid: false, error: "Name must be at least 2 characters" };
+  }
+  if (name.length > 100) {
+    return { valid: false, error: "Name is too long" };
+  }
+  if (!/^[a-zA-Z\s'-]+$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name can only contain letters, spaces, hyphens, and apostrophes"
+    };
+  }
+  return { valid: true };
+};
+var isValidPhone = (phone) => {
+  return REGEX_PATTERNS.PHONE.test(phone);
+};
+var validatePhone = (phone) => {
+  if (!phone) {
+    return { valid: false, error: "Phone number is required" };
+  }
+  if (!isValidPhone(phone)) {
+    return { valid: false, error: "Invalid phone number format" };
+  }
+  return { valid: true };
+};
+var isValidPostalCode = (postalCode) => {
+  return REGEX_PATTERNS.POSTAL_CODE.test(postalCode);
+};
+var validatePostalCode = (postalCode) => {
+  if (!postalCode) {
+    return { valid: false, error: "Postal code is required" };
+  }
+  if (!isValidPostalCode(postalCode)) {
+    return { valid: false, error: "Invalid postal code format" };
+  }
+  return { valid: true };
+};
+var isValidCouponCode = (code) => {
+  return REGEX_PATTERNS.COUPON_CODE.test(code);
+};
+var validateCouponCode = (code) => {
+  if (!code) {
+    return { valid: false, error: "Coupon code is required" };
+  }
+  if (!isValidCouponCode(code)) {
+    return { valid: false, error: "Invalid coupon code format (6-20 alphanumeric characters)" };
+  }
+  return { valid: true };
+};
+var validatePrice = (price) => {
+  const numPrice = parseFloat(price);
+  if (isNaN(numPrice)) {
+    return { valid: false, error: "Price must be a valid number" };
+  }
+  if (numPrice < 0) {
+    return { valid: false, error: "Price cannot be negative" };
+  }
+  if (numPrice > 999999.99) {
+    return { valid: false, error: "Price exceeds maximum allowed value" };
+  }
+  return { valid: true };
+};
+var validateQuantity = (qty) => {
+  const numQty = parseInt(qty, 10);
+  if (isNaN(numQty)) {
+    return { valid: false, error: "Quantity must be a valid number" };
+  }
+  if (numQty < 0) {
+    return { valid: false, error: "Quantity cannot be negative" };
+  }
+  if (!Number.isInteger(numQty)) {
+    return { valid: false, error: "Quantity must be a whole number" };
+  }
+  return { valid: true };
+};
+var validateRating = (rating) => {
+  const numRating = parseFloat(rating);
+  if (isNaN(numRating)) {
+    return { valid: false, error: "Rating must be a valid number" };
+  }
+  if (numRating < 0 || numRating > 5) {
+    return { valid: false, error: "Rating must be between 0 and 5" };
+  }
+  return { valid: true };
+};
+var validateDiscountPercentage = (discount) => {
+  const numDiscount = parseFloat(discount);
+  if (isNaN(numDiscount)) {
+    return { valid: false, error: "Discount must be a valid number" };
+  }
+  if (numDiscount < 0 || numDiscount > 100) {
+    return { valid: false, error: "Discount percentage must be between 0 and 100" };
+  }
+  return { valid: true };
+};
+var validatePagination = (page, limit) => {
+  const numPage = parseInt(page, 10) || 1;
+  const numLimit = parseInt(limit, 10) || 10;
+  if (numPage < 1) {
+    return { valid: false, error: "Page must be greater than 0" };
+  }
+  if (numLimit < 1) {
+    return { valid: false, error: "Limit must be greater than 0" };
+  }
+  if (numLimit > 100) {
+    return { valid: false, error: "Limit cannot exceed 100" };
+  }
+  return { valid: true, page: numPage, limit: numLimit };
+};
+var isValidObjectId = (id) => {
+  return /^[0-9a-fA-F]{24}$/.test(id);
+};
+var validateObjectId = (id, fieldName = "ID") => {
+  if (!id) {
+    return { valid: false, error: `${fieldName} is required` };
+  }
+  if (!isValidObjectId(id)) {
+    return { valid: false, error: `Invalid ${fieldName} format` };
+  }
+  return { valid: true };
+};
+var isValidUrl = (url) => {
+  return REGEX_PATTERNS.URL.test(url);
+};
+var validateUrl = (url) => {
+  if (!url) {
+    return { valid: false, error: "URL is required" };
+  }
+  if (!isValidUrl(url)) {
+    return { valid: false, error: "Invalid URL format" };
+  }
+  return { valid: true };
+};
+var isValidSku = (sku) => {
+  return REGEX_PATTERNS.PRODUCT_SKU.test(sku);
+};
+var validateSku = (sku) => {
+  if (!sku) {
+    return { valid: false, error: "SKU is required" };
+  }
+  if (!isValidSku(sku)) {
+    return {
+      valid: false,
+      error: "Invalid SKU format (3-20 alphanumeric characters with hyphens)"
+    };
+  }
+  return { valid: true };
+};
+var validateDate = (date) => {
+  const dateObj = new Date(date);
+  if (isNaN(dateObj.getTime())) {
+    return { valid: false, error: "Invalid date format" };
+  }
+  return { valid: true };
+};
+var validateDateRange = (startDate, endDate) => {
+  const start = new Date(startDate);
+  const end = new Date(endDate);
+  if (isNaN(start.getTime())) {
+    return { valid: false, error: "Invalid start date" };
+  }
+  if (isNaN(end.getTime())) {
+    return { valid: false, error: "Invalid end date" };
+  }
+  if (start > end) {
+    return { valid: false, error: "Start date must be before end date" };
+  }
+  return { valid: true };
+};
+var batchValidate = (validations) => {
+  const errors = [];
+  for (const validation of validations) {
+    if (!validation.valid && validation.error) {
+      errors.push(validation.error);
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+};
+
+// src/api/logger.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+
+// ../types/dist/index.mjs
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["DEBUG"] = "DEBUG";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["ERROR"] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+
+// src/api/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  [LogLevel.DEBUG]: 0,
+  [LogLevel.INFO]: 1,
+  [LogLevel.WARN]: 2,
+  [LogLevel.ERROR]: 3
+};
+var Logger = class {
+  static configure(options) {
+    if (options.maxLogs !== void 0) this.maxLogs = options.maxLogs;
+    if (options.enableConsole !== void 0) this.enableConsole = options.enableConsole;
+    if (options.enableFile !== void 0) this.enableFile = options.enableFile;
+    if (options.logFilePath) this.logFilePath = options.logFilePath;
+    if (options.logLevel) {
+      const level = typeof options.logLevel === "string" ? options.logLevel.toUpperCase() : options.logLevel;
+      if (Object.values(LogLevel).includes(level)) {
+        this.logLevel = level;
+      }
+    }
+  }
+  static shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.logLevel];
+  }
+  static addLog(entry) {
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) this.logs.shift();
+    if (this.enableFile) {
+      import_fs.default.mkdirSync(import_path.default.dirname(this.logFilePath), { recursive: true });
+      import_fs.default.appendFileSync(this.logFilePath, JSON.stringify(entry) + "\n");
+    }
+  }
+  static format(entry) {
+    return `[${entry.timestamp}] [${entry.level}]${entry.context ? ` [${entry.context}]` : ""}: ${entry.message}`;
+  }
+  static debug(message, data, context) {
+    this.log(LogLevel.DEBUG, message, data, context);
+  }
+  static info(message, data, context) {
+    this.log(LogLevel.INFO, message, data, context);
+  }
+  static warn(message, data, context) {
+    this.log(LogLevel.WARN, message, data, context);
+  }
+  static error(message, error, context) {
+    this.log(LogLevel.ERROR, message, error, context);
+  }
+  static log(level, message, data, context) {
+    if (!this.shouldLog(level)) return;
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      data,
+      context
+    };
+    this.addLog(entry);
+    if (!this.enableConsole) return;
+    const formatted = this.format(entry);
+    switch (level) {
+      case LogLevel.ERROR:
+        console.error(formatted, data ?? "");
+        break;
+      case LogLevel.WARN:
+        console.warn(formatted, data ?? "");
+        break;
+      case LogLevel.INFO:
+        console.info(formatted, data ?? "");
+        break;
+      default:
+        console.debug(formatted, data ?? "");
+    }
+  }
+  static getLogs(level) {
+    return level ? this.logs.filter((l) => l.level === level) : [...this.logs];
+  }
+  static clearLogs() {
+    this.logs = [];
+    if (this.enableFile && import_fs.default.existsSync(this.logFilePath)) {
+      import_fs.default.unlinkSync(this.logFilePath);
+    }
+  }
+};
+Logger.logs = [];
+Logger.maxLogs = 1e3;
+Logger.enableConsole = true;
+Logger.enableFile = false;
+Logger.logFilePath = import_path.default.join(process.cwd(), "logs/app.log");
+Logger.logLevel = LogLevel.DEBUG;
+
+// src/validation/server.ts
+var validate = (req, res, next) => {
+  const errors = (0, import_express_validator.validationResult)(req);
+  if (!errors.isEmpty()) {
+    res.status(400).json({
+      success: false,
+      message: "Validation failed",
+      errors: errors.array().map((err) => ({
+        field: err.type === "field" ? err.path : void 0,
+        message: err.msg
+      }))
+    });
+    return;
+  }
+  next();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Logger,
+  batchValidate,
+  isValidCouponCode,
+  isValidEmail,
+  isValidObjectId,
+  isValidPassword,
+  isValidPhone,
+  isValidPostalCode,
+  isValidSku,
+  isValidUrl,
+  validate,
+  validateCouponCode,
+  validateDate,
+  validateDateRange,
+  validateDiscountPercentage,
+  validateEmail,
+  validateName,
+  validateObjectId,
+  validatePagination,
+  validatePassword,
+  validatePhone,
+  validatePostalCode,
+  validatePrice,
+  validateQuantity,
+  validateRating,
+  validateSku,
+  validateUrl
+});