3a-ecommerce-utils 1.0.0

package/src/api/errorHandler.ts

@@ -0,0 +1,164 @@
+import { ErrorType } from "@e-commerce/types";
+
+export interface AppError {
+  type: ErrorType;
+  message: string;
+  originalError?: any;
+  statusCode?: number;
+}
+
+export class ErrorHandler {
+  static handle(error: any): AppError {
+    if (error.code === 'ECONNABORTED' || error.message === 'Network Error') {
+      return {
+        type: ErrorType.NETWORK_ERROR,
+        message: 'Unable to connect to the server. Please check your internet connection.',
+        originalError: error,
+      };
+    }
+
+    if (error.response) {
+      const { status, data } = error.response;
+
+      switch (status) {
+        case 401:
+          return {
+            type: ErrorType.AUTHENTICATION_ERROR,
+            message: data?.message || 'Authentication failed. Please log in again.',
+            statusCode: status,
+            originalError: error,
+          };
+
+        case 403:
+          return {
+            type: ErrorType.AUTHORIZATION_ERROR,
+            message: data?.message || 'You do not have permission to perform this action.',
+            statusCode: status,
+            originalError: error,
+          };
+
+        case 404:
+          return {
+            type: ErrorType.NOT_FOUND_ERROR,
+            message: data?.message || 'The requested resource was not found.',
+            statusCode: status,
+            originalError: error,
+          };
+
+        case 422:
+          return {
+            type: ErrorType.VALIDATION_ERROR,
+            message: data?.message || 'Invalid input data.',
+            statusCode: status,
+            originalError: error,
+          };
+
+        case 500:
+        case 502:
+        case 503:
+        case 504:
+          return {
+            type: ErrorType.SERVER_ERROR,
+            message: data?.message || 'A server error occurred. Please try again later.',
+            statusCode: status,
+            originalError: error,
+          };
+
+        default:
+          return {
+            type: ErrorType.UNKNOWN_ERROR,
+            message: data?.message || 'An unexpected error occurred.',
+            statusCode: status,
+            originalError: error,
+          };
+      }
+    }
+
+    if (error.graphQLErrors && error.graphQLErrors.length > 0) {
+      const gqlError = error.graphQLErrors[0];
+      return {
+        type: ErrorType.UNKNOWN_ERROR,
+        message: gqlError.message || 'A GraphQL error occurred.',
+        originalError: error,
+      };
+    }
+
+    return {
+      type: ErrorType.UNKNOWN_ERROR,
+      message: error.message || 'An unexpected error occurred.',
+      originalError: error,
+    };
+  }
+
+  static getErrorMessage(error: any): string {
+    return this.handle(error).message;
+  }
+
+  static isAuthError(error: any): boolean {
+    const handled = this.handle(error);
+    return (
+      handled.type === ErrorType.AUTHENTICATION_ERROR ||
+      handled.type === ErrorType.AUTHORIZATION_ERROR
+    );
+  }
+
+  static shouldRetry(error: any): boolean {
+    const handled = this.handle(error);
+    return handled.type === ErrorType.NETWORK_ERROR || handled.type === ErrorType.SERVER_ERROR;
+  }
+}
+
+export interface NotificationOptions {
+  type: 'success' | 'error' | 'warning' | 'info';
+  message: string;
+  duration?: number;
+}
+
+export class ErrorNotifier {
+  private static notifyCallback?: (options: NotificationOptions) => void;
+
+  static setNotifyCallback(callback: (options: NotificationOptions) => void): void {
+    this.notifyCallback = callback;
+  }
+
+  static notifyError(error: any): void {
+    const handled = ErrorHandler.handle(error);
+    if (this.notifyCallback) {
+      this.notifyCallback({
+        type: 'error',
+        message: handled.message,
+        duration: 5000,
+      });
+    }
+  }
+
+  static notifySuccess(message: string): void {
+    if (this.notifyCallback) {
+      this.notifyCallback({
+        type: 'success',
+        message,
+        duration: 3000,
+      });
+    }
+  }
+
+  static notifyWarning(message: string): void {
+    if (this.notifyCallback) {
+      this.notifyCallback({
+        type: 'warning',
+        message,
+        duration: 4000,
+      });
+    }
+  }
+
+  static notifyInfo(message: string): void {
+    if (this.notifyCallback) {
+      this.notifyCallback({
+        type: 'info',
+        message,
+        duration: 3000,
+      });
+    }
+  }
+}

package/src/api/graphqlClient.ts

@@ -0,0 +1,113 @@
+import axios, { AxiosInstance, AxiosRequestConfig } from 'axios';
+
+export interface GraphQLResponse<T = any> {
+  data?: T;
+  errors?: Array<{
+    message: string;
+    locations?: Array<{ line: number; column: number }>;
+    path?: string[];
+    extensions?: any;
+  }>;
+}
+
+export interface GraphQLClientConfig {
+  url: string;
+  headers?: Record<string, string>;
+  tokenStorageKey?: string;
+  onError?: (error: Error) => void;
+}
+
+export class GraphQLClient {
+  private client: AxiosInstance;
+  private tokenStorageKey: string;
+  private onError?: (error: Error) => void;
+
+  constructor(config: GraphQLClientConfig) {
+    this.tokenStorageKey = config.tokenStorageKey || 'auth_token';
+    this.onError = config.onError;
+
+    this.client = axios.create({
+      baseURL: config.url,
+      headers: {
+        'Content-Type': 'application/json',
+        ...config.headers,
+      },
+    });
+
+    this.setupInterceptors();
+  }
+
+  private setupInterceptors(): void {
+    
+    this.client.interceptors.request.use(
+      (config) => {
+        if (typeof window !== 'undefined') {
+          const token = localStorage.getItem(this.tokenStorageKey);
+          if (token) {
+            config.headers.Authorization = `Bearer ${token}`;
+          }
+        }
+        return config;
+      },
+      (error) => {
+        return Promise.reject(error);
+      }
+    );
+
+    this.client.interceptors.response.use(
+      (response) => {
+        
+        if (response.data.errors && response.data.errors.length > 0) {
+          const error = new Error(response.data.errors[0].message);
+          if (this.onError) {
+            this.onError(error);
+          }
+          throw error;
+        }
+        return response;
+      },
+      (error) => {
+        if (this.onError) {
+          this.onError(error);
+        }
+        return Promise.reject(error);
+      }
+    );
+  }
+
+  async request<T = any>(
+    query: string,
+    variables?: Record<string, any>,
+    config?: AxiosRequestConfig
+  ): Promise<T> {
+    try {
+      const response = await this.client.post<GraphQLResponse<T>>('', { query, variables }, config);
+      return response.data.data as T;
+    } catch (error: any) {
+      throw new Error(error?.response?.data?.errors?.[0]?.message || error.message);
+    }
+  }
+
+  setToken(token: string): void {
+    if (typeof window !== 'undefined') {
+      localStorage.setItem(this.tokenStorageKey, token);
+    }
+  }
+
+  clearToken(): void {
+    if (typeof window !== 'undefined') {
+      localStorage.removeItem(this.tokenStorageKey);
+    }
+  }
+
+  getToken(): string | null {
+    if (typeof window !== 'undefined') {
+      return localStorage.getItem(this.tokenStorageKey);
+    }
+    return null;
+  }
+}
+
+export function createGraphQLClient(config: GraphQLClientConfig): GraphQLClient {
+  return new GraphQLClient(config);
+}

package/src/api/index.ts

@@ -0,0 +1,10 @@
+export * from './user.queries';
+export * from './product.queries';
+export * from './order.queries';
+export * from './coupon.queries';
+export * from './category.queries';
+export * from './dashboard.queries';
+export * from './review.queries';
+export * from './address.queries';
+export * from './graphqlClient';
+export * from './logger.client';

package/src/api/logger.client.ts

@@ -0,0 +1,89 @@
+import { LogLevel } from '@e-commerce/types';
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: string;
+  data?: any;
+  context?: string;
+}
+
+/**
+ * Client-safe Logger for frontend applications
+ * Uses console only, no file system access
+ */
+export class Logger {
+  private static logs: LogEntry[] = [];
+  private static maxLogs = 1000;
+  private static enableConsole = true;
+
+  static configure(options: { maxLogs?: number; enableConsole?: boolean }) {
+    if (options.maxLogs !== undefined) this.maxLogs = options.maxLogs;
+    if (options.enableConsole !== undefined) this.enableConsole = options.enableConsole;
+  }
+
+  private static addLog(entry: LogEntry) {
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) this.logs.shift();
+  }
+
+  private static format(entry: LogEntry) {
+    return `[${entry.timestamp}] [${entry.level}]${entry.context ? ` [${entry.context}]` : ''}: ${
+      entry.message
+    }`;
+  }
+
+  static debug(message: string, data?: any, context?: string) {
+    this.log(LogLevel.DEBUG, message, data, context);
+  }
+
+  static info(message: string, data?: any, context?: string) {
+    this.log(LogLevel.INFO, message, data, context);
+  }
+
+  static warn(message: string, data?: any, context?: string) {
+    this.log(LogLevel.WARN, message, data, context);
+  }
+
+  static error(message: string, error?: any, context?: string) {
+    this.log(LogLevel.ERROR, message, error, context);
+  }
+
+  private static log(level: LogLevel, message: string, data?: any, context?: string) {
+    const entry: LogEntry = {
+      level,
+      message,
+      timestamp: 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?: LogLevel): LogEntry[] {
+    return level ? this.logs.filter((l) => l.level === level) : [...this.logs];
+  }
+
+  static clearLogs() {
+    this.logs = [];
+  }
+}

package/src/api/logger.ts

@@ -0,0 +1,135 @@
+/**
+ * Server-side Logger with file system support
+ * For frontend apps, use logger.client.ts instead
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { LogLevel } from '@e-commerce/types';
+
+export interface LogEntry {
+  level: LogLevel;
+  message: string;
+  timestamp: string;
+  data?: any;
+  context?: string;
+}
+
+// Log level priority for filtering
+const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {
+  [LogLevel.DEBUG]: 0,
+  [LogLevel.INFO]: 1,
+  [LogLevel.WARN]: 2,
+  [LogLevel.ERROR]: 3,
+};
+
+export class Logger {
+  private static logs: LogEntry[] = [];
+  private static maxLogs = 1000;
+  private static enableConsole = true;
+  private static enableFile = false;
+  private static logFilePath = path.join(process.cwd(), 'logs/app.log');
+  private static logLevel: LogLevel = LogLevel.DEBUG;
+
+  static configure(options: {
+    maxLogs?: number;
+    enableConsole?: boolean;
+    enableFile?: boolean;
+    logFilePath?: string;
+    logLevel?: LogLevel | string;
+  }) {
+    if (options.maxLogs !== undefined) this.maxLogs = options.maxLogs;
+    if (options.enableConsole !== undefined) this.enableConsole = options.enableConsole;
+    if (options.enableFile !== undefined) this.enableFile = options.enableFile;
+    if (options.logFilePath) this.logFilePath = options.logFilePath;
+    if (options.logLevel) {
+      const level =
+        typeof options.logLevel === 'string'
+          ? (options.logLevel.toUpperCase() as LogLevel)
+          : options.logLevel;
+      if (Object.values(LogLevel).includes(level)) {
+        this.logLevel = level;
+      }
+    }
+  }
+
+  private static shouldLog(level: LogLevel): boolean {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.logLevel];
+  }
+
+  private static addLog(entry: LogEntry) {
+    this.logs.push(entry);
+    if (this.logs.length > this.maxLogs) this.logs.shift();
+
+    if (this.enableFile) {
+      fs.mkdirSync(path.dirname(this.logFilePath), { recursive: true });
+      fs.appendFileSync(this.logFilePath, JSON.stringify(entry) + '\n');
+    }
+  }
+
+  private static format(entry: LogEntry) {
+    return `[${entry.timestamp}] [${entry.level}]${entry.context ? ` [${entry.context}]` : ''}: ${
+      entry.message
+    }`;
+  }
+
+  static debug(message: string, data?: any, context?: string) {
+    this.log(LogLevel.DEBUG, message, data, context);
+  }
+
+  static info(message: string, data?: any, context?: string) {
+    this.log(LogLevel.INFO, message, data, context);
+  }
+
+  static warn(message: string, data?: any, context?: string) {
+    this.log(LogLevel.WARN, message, data, context);
+  }
+
+  static error(message: string, error?: any, context?: string) {
+    this.log(LogLevel.ERROR, message, error, context);
+  }
+
+  private static log(level: LogLevel, message: string, data?: any, context?: string) {
+    // Check if this log level should be logged based on configured level
+    if (!this.shouldLog(level)) return;
+
+    const entry: LogEntry = {
+      level,
+      message,
+      timestamp: 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?: LogLevel): LogEntry[] {
+    return level ? this.logs.filter((l) => l.level === level) : [...this.logs];
+  }
+
+  static clearLogs() {
+    this.logs = [];
+    if (this.enableFile && fs.existsSync(this.logFilePath)) {
+      fs.unlinkSync(this.logFilePath);
+    }
+  }
+}

package/src/api/order.queries.ts

@@ -0,0 +1,211 @@
+export const GET_ORDERS_QUERY = `
+  query GetOrders($page: Int, $limit: Int, $customerId: String) {
+    orders(page: $page, limit: $limit, customerId: $customerId) {
+      orders {
+        id
+        orderNumber
+        customerId
+        customerEmail
+        items {
+          productId
+          productName
+          quantity
+          price
+          subtotal
+        }
+        subtotal
+        tax
+        shipping
+        discount
+        total
+        orderStatus
+        paymentStatus
+        paymentMethod
+        shippingAddress {
+          street
+          city
+          state
+          zip
+          country
+        }
+        notes
+        createdAt
+        updatedAt
+      }
+      pagination {
+        page
+        limit
+        total
+        pages
+      }
+    }
+  }
+`;
+
+export const GET_ORDER_QUERY = `
+  query GetOrder($id: ID!) {
+    order(id: $id) {
+      id
+      orderNumber
+      customerId
+      customerEmail
+      items {
+        productId
+        productName
+        quantity
+        price
+        subtotal
+      }
+      subtotal
+      tax
+      shipping
+      total
+      orderStatus
+      paymentStatus
+      paymentMethod
+      shippingAddress {
+        street
+        city
+        state
+        zip
+        country
+      }
+      notes
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+export const GET_ORDERS_BY_CUSTOMER_QUERY = `
+  query GetOrdersByCustomer($customerId: String!) {
+    ordersByCustomer(customerId: $customerId) {
+      id
+      orderNumber
+      customerId
+      customerEmail
+      items {
+        productId
+        productName
+        quantity
+        price
+        subtotal
+      }
+      subtotal
+      tax
+      shipping
+      total
+      orderStatus
+      paymentStatus
+      paymentMethod
+      shippingAddress {
+        street
+        city
+        state
+        zip
+        country
+      }
+      notes
+      createdAt
+      updatedAt
+    }
+  }
+`;
+
+export const CREATE_ORDER_MUTATION = `
+  mutation CreateOrder($input: CreateOrderInput!) {
+    createOrder(input: $input) {
+      order {
+        id
+        orderNumber
+        customerId
+        customerEmail
+        sellerId
+        items {
+          productId
+          productName
+          quantity
+          price
+          sellerId
+          subtotal
+        }
+        subtotal
+        tax
+        shipping
+        discount
+        couponCode
+        total
+        orderStatus
+        paymentStatus
+        paymentMethod
+        shippingAddress {
+          street
+          city
+          state
+          zip
+          country
+        }
+        notes
+        createdAt
+        updatedAt
+      }
+      orders {
+        id
+        orderNumber
+        customerId
+        customerEmail
+        sellerId
+        items {
+          productId
+          productName
+          quantity
+          price
+          sellerId
+          subtotal
+        }
+        subtotal
+        tax
+        shipping
+        discount
+        total
+        orderStatus
+        paymentStatus
+        createdAt
+      }
+      orderCount
+    }
+  }
+`;
+
+export const UPDATE_ORDER_STATUS_MUTATION = `
+  mutation UpdateOrderStatus($id: ID!, $status: OrderStatus!) {
+    updateOrderStatus(id: $id, status: $status) {
+      id
+      orderNumber
+      orderStatus
+      updatedAt
+    }
+  }
+`;
+
+export const UPDATE_PAYMENT_STATUS_MUTATION = `
+  mutation UpdatePaymentStatus($id: ID!, $status: PaymentStatus!) {
+    updatePaymentStatus(id: $id, status: $status) {
+      id
+      orderNumber
+      paymentStatus
+      updatedAt
+    }
+  }
+`;
+
+export const CANCEL_ORDER_MUTATION = `
+  mutation CancelOrder($id: ID!) {
+    cancelOrder(id: $id) {
+      id
+      orderNumber
+      orderStatus
+      updatedAt
+    }
+  }
+`;