rbac-manager 0.0.0-stage → 1.0.0

package/src/core/adapters/mastersAdapter.ts

@@ -0,0 +1,132 @@
+import { RBAC_CONSTANTS } from '../../constants';
+import {
+  MastersAdapter,
+  StandardEntityMaster,
+  StandardDepartmentMaster,
+  StandardDesignationMaster,
+  StandardEmployeeMaster,
+  StandardModuleMasterItem,
+  PaginatedResult,
+} from '../types';
+
+function extractListAndMeta(raw: any): { itemsRaw: any[]; total: number; page: number; limit: number } {
+  const dataKey = RBAC_CONSTANTS.api.DATA;
+  const pagKeys = RBAC_CONSTANTS.pagination;
+  const root = raw?.[dataKey] ?? raw;
+
+  if (Array.isArray(root)) {
+    return { itemsRaw: root, total: root.length, page: 1, limit: 10 };
+  } else if (root && typeof root === 'object') {
+    const itemsRaw = root[pagKeys.ITEMS] || root.items || root.rows || [];
+    const total = root[pagKeys.TOTAL] ?? itemsRaw.length;
+    const page = root[pagKeys.PAGE] ?? 1;
+    const limit = root[pagKeys.LIMIT] ?? 10;
+    return { itemsRaw, total, page, limit };
+  }
+  return { itemsRaw: [], total: 0, page: 1, limit: 10 };
+}
+
+export const defaultMastersAdapter: MastersAdapter = {
+  transformEntityListResponse: (raw: any): PaginatedResult<StandardEntityMaster> => {
+    const k = RBAC_CONSTANTS.masters.ENTITY;
+    const { itemsRaw, total, page, limit } = extractListAndMeta(raw);
+
+    const items = itemsRaw.map((e: any) => ({
+      id: e[k.ID] ?? e.id,
+      name: e[k.NAME] ?? e.name,
+      code: e[k.CODE],
+      state: e[k.STATE],
+      city: e[k.CITY],
+      pincode: e[k.PINCODE],
+      isActive: Boolean(e[RBAC_CONSTANTS.masters.IS_ACTIVE] ?? e.is_active ?? true),
+      createdAt: e[RBAC_CONSTANTS.masters.CREATED_AT],
+    }));
+
+    return { items, total, page, limit };
+  },
+
+  transformDepartmentListResponse: (raw: any): PaginatedResult<StandardDepartmentMaster> => {
+    const k = RBAC_CONSTANTS.masters.DEPARTMENT;
+    const { itemsRaw, total, page, limit } = extractListAndMeta(raw);
+
+    const items = itemsRaw.map((d: any) => ({
+      id: d[k.ID] ?? d.id,
+      name: d[k.NAME] ?? d.name,
+      code: d[k.CODE],
+      entityId: d[k.ENTITY_ID] ?? d.entity?.entityId,
+      entityName: d.entity?.entity_name ?? d.entityName,
+      isActive: Boolean(d[RBAC_CONSTANTS.masters.IS_ACTIVE] ?? d.is_active ?? true),
+      createdAt: d[RBAC_CONSTANTS.masters.CREATED_AT],
+    }));
+
+    return { items, total, page, limit };
+  },
+
+  transformDesignationListResponse: (raw: any): PaginatedResult<StandardDesignationMaster> => {
+    const k = RBAC_CONSTANTS.masters.DESIGNATION;
+    const { itemsRaw, total, page, limit } = extractListAndMeta(raw);
+
+    const items = itemsRaw.map((des: any) => ({
+      id: des[k.ID] ?? des.id,
+      name: des[k.NAME] ?? des.name,
+      code: des[k.CODE],
+      departmentId: des[k.DEPARTMENT_ID] ?? des.department?.departmentId,
+      departmentName: des.department?.department_name ?? des.departmentName,
+      isActive: Boolean(des[RBAC_CONSTANTS.masters.IS_ACTIVE] ?? des.is_active ?? true),
+      createdAt: des[RBAC_CONSTANTS.masters.CREATED_AT],
+    }));
+
+    return { items, total, page, limit };
+  },
+
+  transformEmployeeListResponse: (raw: any): PaginatedResult<StandardEmployeeMaster> => {
+    const k = RBAC_CONSTANTS.masters.EMPLOYEE;
+    const { itemsRaw, total, page, limit } = extractListAndMeta(raw);
+
+    const items = itemsRaw.map((emp: any) => {
+      const fn = emp[k.FIRST_NAME] || '';
+      const ln = emp[k.LAST_NAME] || '';
+      return {
+        id: emp[k.ID] ?? emp.id,
+        employeeCode: emp[k.EMPLOYEE_CODE],
+        firstName: fn,
+        lastName: ln,
+        fullName: `${fn} ${ln}`.trim() || emp.name || emp[k.EMAIL] || '',
+        email: emp[k.EMAIL] || '',
+        mobileNumber: emp[k.MOBILE_NUMBER],
+        entityId: emp[k.ENTITY_ID],
+        entityName: emp.entity?.entity_name,
+        departmentId: emp[k.DEPARTMENT_ID],
+        departmentName: emp.department?.department_name,
+        designationId: emp[k.DESIGNATION_ID],
+        designationName: emp.designation?.designation_name,
+        reportingManagerId: emp[k.REPORTING_MANAGER_ID],
+        roleId: emp[k.ROLE_ID] ?? emp.role?.id,
+        roleName: emp.role?.role_name,
+        isActive: Boolean(emp[RBAC_CONSTANTS.masters.IS_ACTIVE] ?? emp.is_active ?? true),
+        createdAt: emp[RBAC_CONSTANTS.masters.CREATED_AT],
+      };
+    });
+
+    return { items, total, page, limit };
+  },
+
+  transformModuleMasterListResponse: (raw: any): PaginatedResult<StandardModuleMasterItem> => {
+    const k = RBAC_CONSTANTS.masters.MODULE;
+    const { itemsRaw, total, page, limit } = extractListAndMeta(raw);
+
+    const items = itemsRaw.map((m: any) => ({
+      id: m[k.ID] ?? m.id,
+      name: m[k.NAME] ?? m.name,
+      slug: m[k.SLUG_NAME] ?? m.slug,
+      routePath: m[k.ROUTE_PATH],
+      sortOrder: m[k.SORT_ORDER] || 0,
+      parentId: m[k.PARENT_ID] || 0,
+      parentName: m.parent?.name,
+      isActive: Boolean(m[RBAC_CONSTANTS.masters.IS_ACTIVE] ?? m.is_active ?? true),
+      createdAt: m[RBAC_CONSTANTS.masters.CREATED_AT],
+    }));
+
+    return { items, total, page, limit };
+  },
+};

package/src/core/adapters/permissionsAdapter.ts

@@ -0,0 +1,90 @@
+import { RBAC_CONSTANTS } from '../../constants';
+import { PermissionsAdapter, StandardAction, StandardModuleWithActions, PaginatedResult } from '../types';
+
+export const defaultPermissionsAdapter: PermissionsAdapter = {
+  transformActionsListResponse: (raw: any): StandardAction[] => {
+    const dataKey = RBAC_CONSTANTS.api.DATA;
+    const root = raw?.[dataKey] || raw || [];
+    const items = Array.isArray(root) ? root : root.list || [];
+
+    return items.map((a: any) => ({
+      id: a[RBAC_CONSTANTS.permissions.ACTION_ID] ?? a.id,
+      name: a[RBAC_CONSTANTS.permissions.ACTION_NAME] ?? a.name,
+      key: a[RBAC_CONSTANTS.permissions.ACTION_KEY] ?? a.key,
+      isActive: Boolean(a[RBAC_CONSTANTS.permissions.IS_ACTIVE] ?? true),
+      sortOrder: a.sort_order ?? 0,
+    }));
+  },
+
+  transformRegistryResponse: (raw: any): PaginatedResult<StandardModuleWithActions> => {
+    const permKeys = RBAC_CONSTANTS.permissions;
+    const dataKey = RBAC_CONSTANTS.api.DATA;
+    const pagKeys = RBAC_CONSTANTS.pagination;
+
+    let itemsRaw: any[] = [];
+    let total = 0;
+    let page = 1;
+    let limit = 10;
+
+    const root = raw?.[dataKey] ?? raw;
+    if (Array.isArray(root)) {
+      itemsRaw = root;
+      total = root.length;
+    } else if (root && typeof root === 'object') {
+      itemsRaw = root[pagKeys.ITEMS] || root.items || [];
+      total = root[pagKeys.TOTAL] ?? itemsRaw.length;
+      page = root[pagKeys.PAGE] ?? 1;
+      limit = root[pagKeys.LIMIT] ?? 10;
+    }
+
+    const mapModule = (m: any): StandardModuleWithActions => {
+      const rawActions = m[permKeys.ACTIONS_ARRAY] || [];
+      const actions = Array.isArray(rawActions)
+        ? rawActions.map((pa: any) => {
+            const ad = pa[permKeys.ACTION_DETAILS] || {};
+            return {
+              permissionActionId: pa[permKeys.PERMISSION_ACTION_ID] ?? pa.id,
+              moduleId: pa[permKeys.PERMISSION_MASTER_ID] ?? m[permKeys.PERMISSION_MASTER_ID],
+              actionId: pa[permKeys.ACTION_ID] ?? ad[permKeys.ACTION_ID],
+              permissionKey: pa[permKeys.PERMISSION_KEY] || '',
+              routePath: pa[permKeys.ROUTE_PATH],
+              description: pa.description,
+              sortOrder: pa[permKeys.SORT_ORDER] || 0,
+              actionDetails: {
+                id: ad[permKeys.ACTION_ID] ?? pa[permKeys.ACTION_ID] ?? 0,
+                name: ad[permKeys.ACTION_NAME] || pa[permKeys.ACTION_NAME] || '',
+                key: ad[permKeys.ACTION_KEY] || pa[permKeys.ACTION_KEY] || '',
+                isActive: Boolean(ad[permKeys.IS_ACTIVE] ?? true),
+              },
+            };
+          })
+        : [];
+
+      const rawChildren = m[permKeys.CHILDREN_ARRAY] || m[permKeys.SUBMODULES_ARRAY] || [];
+      const children = Array.isArray(rawChildren) ? rawChildren.map(mapModule) : [];
+
+      return {
+        id: m[permKeys.PERMISSION_MASTER_ID] ?? m.id,
+        name: m[permKeys.MODULE_NAME] || '',
+        slug: m[permKeys.SLUG_NAME] || '',
+        routePath: m[permKeys.ROUTE_PATH],
+        sortOrder: m[permKeys.SORT_ORDER] || 0,
+        parentId: m[permKeys.PARENT_ID] || 0,
+        isActive: Boolean(m[permKeys.IS_ACTIVE] ?? true),
+        actions,
+        children,
+      };
+    };
+
+    const items = itemsRaw.map(mapModule);
+    return { items, total, page, limit };
+  },
+
+  transformModuleParentsResponse: (raw: any): PaginatedResult<StandardModuleWithActions> => {
+    return defaultPermissionsAdapter.transformRegistryResponse(raw);
+  },
+
+  transformModuleSubmodulesResponse: (raw: any): PaginatedResult<StandardModuleWithActions> => {
+    return defaultPermissionsAdapter.transformRegistryResponse(raw);
+  },
+};

package/src/core/adapters/rolesAdapter.ts

@@ -0,0 +1,115 @@
+import { RBAC_CONSTANTS } from '../../constants';
+import { RolesAdapter, StandardRole, PaginatedResult, RoleFormData } from '../types';
+
+export const defaultRolesAdapter: RolesAdapter = {
+  transformRoleListResponse: (raw: any): PaginatedResult<StandardRole> => {
+    const roleKeys = RBAC_CONSTANTS.roles;
+    const dataKey = RBAC_CONSTANTS.api.DATA;
+    const pagKeys = RBAC_CONSTANTS.pagination;
+
+    let itemsRaw: any[] = [];
+    let total = 0;
+    let page = 1;
+    let limit = 10;
+
+    const root = raw?.[dataKey] ?? raw;
+
+    if (Array.isArray(root)) {
+      itemsRaw = root;
+      total = root.length;
+    } else if (root && typeof root === 'object') {
+      itemsRaw = root[pagKeys.ITEMS] || root.roles || root.items || root.rows || [];
+      total = root[pagKeys.TOTAL] ?? itemsRaw.length;
+      page = root[pagKeys.PAGE] ?? 1;
+      limit = root[pagKeys.LIMIT] ?? 10;
+    }
+
+    const items: StandardRole[] = itemsRaw.map((r: any) => {
+      const entityObj = r[roleKeys.ENTITY_OBJECT];
+      const deptObj = r[roleKeys.DEPARTMENT_OBJECT];
+
+      return {
+        id: r[roleKeys.ID] ?? r[roleKeys.ROLE_ID],
+        name: r[roleKeys.ROLE_NAME] || '',
+        key: r[roleKeys.ROLE_KEY] || '',
+        description: r[roleKeys.DESCRIPTION],
+        isActive: Boolean(r[roleKeys.IS_ACTIVE] ?? true),
+        entityId: r[roleKeys.ENTITY_ID] ?? entityObj?.[RBAC_CONSTANTS.masters.ENTITY.ID],
+        entityName: entityObj?.[roleKeys.ENTITY_NAME] ?? entityObj?.name,
+        departmentId: r[roleKeys.DEPARTMENT_ID] ?? deptObj?.[RBAC_CONSTANTS.masters.DEPARTMENT.ID],
+        departmentName: deptObj?.[roleKeys.DEPARTMENT_NAME] ?? deptObj?.name,
+        createdAt: r[roleKeys.CREATED_AT],
+        updatedAt: r[roleKeys.UPDATED_AT],
+      };
+    });
+
+    return { items, total, page, limit };
+  },
+
+  transformRoleDetailsResponse: (raw: any): StandardRole => {
+    const roleKeys = RBAC_CONSTANTS.roles;
+    const dataKey = RBAC_CONSTANTS.api.DATA;
+    const r = raw?.[dataKey] || raw || {};
+
+    return {
+      id: r[roleKeys.ID] ?? r[roleKeys.ROLE_ID],
+      name: r[roleKeys.ROLE_NAME] || '',
+      key: r[roleKeys.ROLE_KEY] || '',
+      description: r[roleKeys.DESCRIPTION],
+      isActive: Boolean(r[roleKeys.IS_ACTIVE] ?? true),
+      entityId: r[roleKeys.ENTITY_ID],
+      departmentId: r[roleKeys.DEPARTMENT_ID],
+      createdAt: r[roleKeys.CREATED_AT],
+      updatedAt: r[roleKeys.UPDATED_AT],
+    };
+  },
+
+  transformCreateRolePayload: (data: RoleFormData): Record<string, any> => {
+    const roleKeys = RBAC_CONSTANTS.roles;
+    return {
+      [roleKeys.ROLE_NAME]: data.role_name,
+      [roleKeys.ROLE_KEY]: data.role_key,
+      [roleKeys.DESCRIPTION]: data.description || '',
+      ...(data.entityId ? { [roleKeys.ENTITY_ID]: data.entityId } : {}),
+      ...(data.departmentId ? { [roleKeys.DEPARTMENT_ID]: data.departmentId } : {}),
+      [roleKeys.IS_ACTIVE]: data.is_active ?? true,
+    };
+  },
+
+  transformEditRolePayload: (data: Partial<RoleFormData>): Record<string, any> => {
+    const roleKeys = RBAC_CONSTANTS.roles;
+    const payload: Record<string, any> = {};
+    if (data.role_name !== undefined) payload[roleKeys.ROLE_NAME] = data.role_name;
+    if (data.role_key !== undefined) payload[roleKeys.ROLE_KEY] = data.role_key;
+    if (data.description !== undefined) payload[roleKeys.DESCRIPTION] = data.description;
+    if (data.entityId !== undefined) payload[roleKeys.ENTITY_ID] = data.entityId;
+    if (data.departmentId !== undefined) payload[roleKeys.DEPARTMENT_ID] = data.departmentId;
+    if (data.is_active !== undefined) payload[roleKeys.IS_ACTIVE] = data.is_active;
+    return payload;
+  },
+
+  transformRolePermissionsResponse: (raw: any): (string | number)[] => {
+    const dataKey = RBAC_CONSTANTS.api.DATA;
+    const root = raw?.[dataKey] || raw || {};
+    const permissions = root[RBAC_CONSTANTS.roles.ASSIGNED_PERMISSIONS_ARRAY] || root.permissionActionIds || root;
+
+    if (Array.isArray(permissions)) {
+      return permissions.map((p: any) => {
+        if (typeof p === 'number' || typeof p === 'string') return p;
+        return (
+          p[RBAC_CONSTANTS.permissions.PERMISSION_ACTION_ID] ??
+          p[RBAC_CONSTANTS.permissions.ACTION_ID] ??
+          p[RBAC_CONSTANTS.permissions.PERMISSION_KEY_ID] ??
+          p.id
+        );
+      });
+    }
+    return [];
+  },
+
+  transformAssignPermissionsPayload: (_roleId: string | number, permissionActionIds: (string | number)[]) => {
+    return {
+      [RBAC_CONSTANTS.roles.ASSIGNED_ACTION_IDS_PAYLOAD_KEY]: permissionActionIds,
+    };
+  },
+};

package/src/core/api/httpClient.ts

@@ -0,0 +1,296 @@
+export interface RequestOptions extends RequestInit {
+  params?: Record<string, string | number | boolean | undefined | null>;
+  skipAuthRedirect?: boolean;
+  skipTokenRefresh?: boolean;
+}
+
+export function extractFieldErrors(data: any): Record<string, string> | undefined {
+  if (!data || typeof data !== 'object') return undefined;
+
+  // Pattern 1: { fieldErrors: { email: "taken" } }
+  if (data.fieldErrors && typeof data.fieldErrors === 'object' && !Array.isArray(data.fieldErrors)) {
+    return data.fieldErrors;
+  }
+
+  // Pattern 2: { errors: { email: "taken" | ["taken", "invalid"] } }
+  if (data.errors && typeof data.errors === 'object' && !Array.isArray(data.errors)) {
+    const res: Record<string, string> = {};
+    for (const [k, v] of Object.entries(data.errors)) {
+      res[k] = Array.isArray(v) ? String(v[0]) : String(v);
+    }
+    return res;
+  }
+
+  // Pattern 3: { errors: [{ field: "email", message: "taken" }] } or [{ path: "email", msg: "taken" }]
+  if (Array.isArray(data.errors)) {
+    const res: Record<string, string> = {};
+    for (const item of data.errors) {
+      const key = item.field || item.path || item.param || item.key;
+      const msg = item.message || item.msg || item.error;
+      if (key && msg) res[key] = String(msg);
+    }
+    return Object.keys(res).length > 0 ? res : undefined;
+  }
+
+  // Pattern 4: { validationErrors: { ... } }
+  if (data.validationErrors && typeof data.validationErrors === 'object') {
+    const res: Record<string, string> = {};
+    for (const [k, v] of Object.entries(data.validationErrors)) {
+      res[k] = Array.isArray(v) ? String(v[0]) : String(v);
+    }
+    return res;
+  }
+
+  return undefined;
+}
+
+export class HttpClient {
+  private baseUrl: string;
+  private getToken?: () => string | null | undefined;
+  private getTenantId?: () => string | number | null | undefined;
+  private getCustomHeaders?: () => Record<string, string>;
+  private onUnauthorized?: () => void;
+  private refreshTokenFn?: () => Promise<string | null | undefined>;
+
+  private isRefreshing = false;
+  private refreshSubscribers: Array<(token: string | null) => void> = [];
+
+  constructor(options: {
+    baseUrl: string;
+    getToken?: () => string | null | undefined;
+    getTenantId?: () => string | number | null | undefined;
+    getCustomHeaders?: () => Record<string, string>;
+    onUnauthorized?: () => void;
+    refreshToken?: () => Promise<string | null | undefined>;
+  }) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.getToken = options.getToken;
+    this.getTenantId = options.getTenantId;
+    this.getCustomHeaders = options.getCustomHeaders;
+    this.onUnauthorized = options.onUnauthorized;
+    this.refreshTokenFn = options.refreshToken;
+  }
+
+  public setBaseUrl(url: string) {
+    this.baseUrl = url.replace(/\/$/, "");
+  }
+
+  private subscribeTokenRefresh(cb: (token: string | null) => void) {
+    this.refreshSubscribers.push(cb);
+  }
+
+  private onTokenRefreshed(token: string | null) {
+    this.refreshSubscribers.forEach((cb) => cb(token));
+    this.refreshSubscribers = [];
+  }
+
+  private buildUrl(path: string, params?: Record<string, any>): string {
+    const cleanPath = path.startsWith("/") ? path : `/${path}`;
+    const url = new URL(`${this.baseUrl}${cleanPath}`);
+
+    if (params) {
+      Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== '') {
+          url.searchParams.append(key, String(value));
+        }
+      });
+    }
+
+    return url.toString();
+  }
+
+  public async request<T = any>(
+    path: string,
+    options: RequestOptions = {},
+  ): Promise<T> {
+    const url = this.buildUrl(path, options.params);
+    const headers: Record<string, string> = {
+      ...((options.headers as Record<string, string>) || {}),
+    };
+
+    const isFormData =
+      typeof FormData !== "undefined" && options.body instanceof FormData;
+    if (!isFormData && !headers["Content-Type"]) {
+      headers["Content-Type"] = "application/json";
+    } else if (isFormData) {
+      delete headers["Content-Type"]; // Let browser generate boundary
+    }
+
+    // Inject custom headers if configured
+    if (this.getCustomHeaders) {
+      Object.assign(headers, this.getCustomHeaders());
+    }
+
+    // Inject tenant/entity identifier if configured
+    if (this.getTenantId) {
+      const tenantId = this.getTenantId();
+      if (tenantId) {
+        headers["X-Tenant-Id"] = String(tenantId);
+        headers["X-Entity-Id"] = String(tenantId);
+      }
+    }
+
+    // Inject Bearer token
+    const token = this.getToken ? this.getToken() : null;
+    if (token && !headers["Authorization"]) {
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+
+    let response: Response;
+    try {
+      response = await fetch(url, {
+        ...options,
+        headers,
+        credentials: options.credentials || 'include',
+      });
+    } catch (networkError: any) {
+      throw new Error(
+        `Network error: ${networkError.message || "Failed to fetch"}`,
+      );
+    }
+
+    // Handle 401 Unauthorized with Silent Token Refresh
+    if (response.status === 401 && !options.skipAuthRedirect) {
+      if (this.refreshTokenFn && !options.skipTokenRefresh) {
+        if (!this.isRefreshing) {
+          this.isRefreshing = true;
+          try {
+            const newToken = await this.refreshTokenFn();
+            this.isRefreshing = false;
+            this.onTokenRefreshed(newToken || null);
+
+            if (newToken) {
+              // Retry original request with newly refreshed token
+              headers["Authorization"] = `Bearer ${newToken}`;
+              return this.request<T>(path, {
+                ...options,
+                headers,
+                skipTokenRefresh: true,
+              });
+            }
+          } catch (refreshErr) {
+            this.isRefreshing = false;
+            this.onTokenRefreshed(null);
+            if (this.onUnauthorized) this.onUnauthorized();
+            throw refreshErr;
+          }
+        } else {
+          // Another request is already refreshing the token; wait for it
+          return new Promise<T>((resolve, reject) => {
+            this.subscribeTokenRefresh((newToken) => {
+              if (newToken) {
+                headers["Authorization"] = `Bearer ${newToken}`;
+                resolve(
+                  this.request<T>(path, {
+                    ...options,
+                    headers,
+                    skipTokenRefresh: true,
+                  }),
+                );
+              } else {
+                if (this.onUnauthorized) this.onUnauthorized();
+                reject(new Error("Session expired"));
+              }
+            });
+          });
+        }
+      }
+
+      // If no refreshToken handler, trigger unauthorized callback
+      if (this.onUnauthorized) {
+        this.onUnauthorized();
+      }
+    }
+
+    const data = await response.json().catch(() => null);
+
+    if (!response.ok) {
+      const errorMsg =
+        data?.message ||
+        data?.error ||
+        `Request failed with status ${response.status}`;
+      const error: any = new Error(errorMsg);
+      error.status = response.status;
+      error.data = data;
+      // Extract field-level validation errors if returned by backend
+      error.fieldErrors = extractFieldErrors(data);
+      throw error;
+    }
+
+    return data as T;
+  }
+
+  public get<T = any>(
+    path: string,
+    params?: Record<string, any>,
+    options?: RequestOptions,
+  ): Promise<T> {
+    return this.request<T>(path, { ...options, method: "GET", params });
+  }
+
+  public post<T = any>(
+    path: string,
+    body?: any,
+    options?: RequestOptions,
+  ): Promise<T> {
+    const isFormData =
+      typeof FormData !== "undefined" && body instanceof FormData;
+    return this.request<T>(path, {
+      ...options,
+      method: "POST",
+      body: isFormData
+        ? body
+        : body !== undefined
+          ? JSON.stringify(body)
+          : undefined,
+    });
+  }
+
+  public patch<T = any>(
+    path: string,
+    body?: any,
+    options?: RequestOptions,
+  ): Promise<T> {
+    const isFormData =
+      typeof FormData !== "undefined" && body instanceof FormData;
+    return this.request<T>(path, {
+      ...options,
+      method: "PATCH",
+      body: isFormData
+        ? body
+        : body !== undefined
+          ? JSON.stringify(body)
+          : undefined,
+    });
+  }
+
+  public put<T = any>(
+    path: string,
+    body?: any,
+    options?: RequestOptions,
+  ): Promise<T> {
+    const isFormData =
+      typeof FormData !== "undefined" && body instanceof FormData;
+    return this.request<T>(path, {
+      ...options,
+      method: "PUT",
+      body: isFormData
+        ? body
+        : body !== undefined
+          ? JSON.stringify(body)
+          : undefined,
+    });
+  }
+
+  public delete<T = any>(path: string, options?: RequestOptions): Promise<T> {
+    return this.request<T>(path, { ...options, method: "DELETE" });
+  }
+
+  public upload<T = any>(path: string, formData: FormData, options?: RequestOptions): Promise<T> {
+    return this.request<T>(path, {
+      ...options,
+      method: 'POST',
+      body: formData,
+    });
+  }
+}