@alba-cars/common-modules 1.3.2 → 1.3.4

package/dist/core/error-handling/AppError.d.ts

@@ -4,7 +4,9 @@ export declare enum ErrorType {
     UNAUTHORIZED = "UNAUTHORIZED",
     FORBIDDEN = "FORBIDDEN",
     INTERNAL_SERVER_ERROR = "INTERNAL_SERVER_ERROR",
-    BAD_REQUEST = "BAD_REQUEST"
+    BAD_REQUEST = "BAD_REQUEST",
+    AUTHENTICATION_ERROR = "AUTHENTICATION_ERROR",
+    AUTHORIZATION_ERROR = "AUTHORIZATION_ERROR"
 }
 export declare class AppError extends Error {
     message: string;

package/dist/core/error-handling/AppError.js

@@ -10,6 +10,8 @@ var ErrorType;
     ErrorType["FORBIDDEN"] = "FORBIDDEN";
     ErrorType["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
     ErrorType["BAD_REQUEST"] = "BAD_REQUEST";
+    ErrorType["AUTHENTICATION_ERROR"] = "AUTHENTICATION_ERROR";
+    ErrorType["AUTHORIZATION_ERROR"] = "AUTHORIZATION_ERROR";
 })(ErrorType = exports.ErrorType || (exports.ErrorType = {}));
 class AppError extends Error {
     constructor(message, statusCode, type, details) {

package/dist/core/network/endpoint-config.d.ts

@@ -9,6 +9,10 @@ interface BaseEndpoint {
 interface VehicleEndpoints extends BaseEndpoint {
     getSimilar: EndpointFunction;
     getOneBySlug: EndpointFunction;
+    publishVehicle: EndpointFunction;
+    reserveVehicle: EndpointFunction;
+    selfReserveVehicle: EndpointFunction;
+    markVehicleSold: EndpointFunction;
 }
 interface BlogEndpoints extends BaseEndpoint {
     getOneBySlug: EndpointFunction;
@@ -32,6 +36,7 @@ type APIEndpointType = {
     sellCarRequest: BaseEndpoint;
     financeEligibilityRequest: BaseEndpoint;
     vehicleReservations: BaseEndpoint;
+    languages: BaseEndpoint;
 };
 export declare const API_ENDPOINTS: APIEndpointType;
 export declare const UTIL_ENDPOINTS: {
@@ -40,4 +45,9 @@ export declare const UTIL_ENDPOINTS: {
         preprocessMediaUrl: string;
     };
 };
+export declare const AUTH_ENDPOINTS: {
+    login: string;
+    register: string;
+    getLoggedInUser: string;
+};
 export {};

package/dist/core/network/endpoint-config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UTIL_ENDPOINTS = exports.API_ENDPOINTS = void 0;
+exports.AUTH_ENDPOINTS = exports.UTIL_ENDPOINTS = exports.API_ENDPOINTS = void 0;
 exports.API_ENDPOINTS = {
     vehicle: {
         getAll: `/vehicle`,
@@ -10,6 +10,10 @@ exports.API_ENDPOINTS = {
         getSimilar: (id) => `/vehicle/similar/${id}`,
         deleteOne: (id) => `/vehicle/${id}`,
         updateOne: (id) => `/vehicle/${id}`,
+        publishVehicle: (id) => `/vehicle/publish/${id}`,
+        reserveVehicle: (id) => `/vehicle/reserve/${id}`,
+        selfReserveVehicle: (id) => `/vehicle/self-reserve/${id}`,
+        markVehicleSold: (id) => `/vehicle/mark-vehicle-sold/${id}`,
     },
     vehicleDetails: {
         getAll: `/vehicledetails`,
@@ -130,7 +134,14 @@ exports.API_ENDPOINTS = {
         getOne: (id) => `/vehicle-reservation/${id}`,
         deleteOne: (id) => `/vehicle-reservation/${id}`,
         updateOne: (id) => `/vehicle-reservation/${id}`,
-    }
+    },
+    languages: {
+        getAll: `/languages`,
+        create: `/languages`,
+        getOne: (id) => `/languages/${id}`,
+        deleteOne: (id) => `/languages/${id}`,
+        updateOne: (id) => `/languages/${id}`,
+    },
 };
 exports.UTIL_ENDPOINTS = {
     media: {
@@ -138,3 +149,8 @@ exports.UTIL_ENDPOINTS = {
         preprocessMediaUrl: "/utils/process-media",
     },
 };
+exports.AUTH_ENDPOINTS = {
+    login: "/auth/login",
+    register: "/auth/register",
+    getLoggedInUser: "/auth/me",
+};

package/dist/core/network/fetch-api.d.ts

@@ -1,6 +1,14 @@
 interface ApiRequestOptions extends RequestInit {
     headers?: Record<string, string>;
     query?: Record<string, any>;
+    skipAuth?: boolean;
 }
+interface Tokens {
+    accessToken: string;
+    refreshToken: string;
+}
+export declare const getTokens: () => Tokens | null;
+export declare const setTokens: (tokens: Tokens) => void;
+export declare const removeTokens: () => void;
 export declare function apiRequest<T>(endpoint: string, options?: ApiRequestOptions): Promise<T>;
 export {};

package/dist/core/network/fetch-api.js

@@ -3,67 +3,158 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiRequest = void 0;
+exports.apiRequest = exports.removeTokens = exports.setTokens = exports.getTokens = void 0;
 const qs_1 = __importDefault(require("qs"));
-const utils_1 = require("../utils");
 const enums_1 = require("../enums");
 const BASE_URL = process.env.NEXT_PUBLIC_API_URL;
+const AUTH_STORAGE_KEY = "auth_tokens";
+let isRefreshing = false;
+let refreshSubscribers = [];
+const getTokens = () => {
+    if (typeof window === "undefined")
+        return null;
+    const tokens = localStorage.getItem(AUTH_STORAGE_KEY);
+    return tokens ? JSON.parse(tokens) : null;
+};
+exports.getTokens = getTokens;
+const setTokens = (tokens) => {
+    localStorage.setItem(AUTH_STORAGE_KEY, JSON.stringify(tokens));
+};
+exports.setTokens = setTokens;
+const removeTokens = () => {
+    localStorage.removeItem(AUTH_STORAGE_KEY);
+};
+exports.removeTokens = removeTokens;
+const subscribeTokenRefresh = (cb) => {
+    refreshSubscribers.push(cb);
+};
+const onTokenRefreshed = (token) => {
+    refreshSubscribers.forEach((cb) => cb(token));
+    refreshSubscribers = [];
+};
+const refreshTokens = async () => {
+    try {
+        const tokens = (0, exports.getTokens)();
+        if (!(tokens === null || tokens === void 0 ? void 0 : tokens.refreshToken)) {
+            throw new Error("No refresh token available");
+        }
+        const response = await apiRequest("/auth/refresh", {
+            method: enums_1.HttpMethods.POST,
+            body: JSON.stringify({ refreshToken: tokens.refreshToken }),
+            skipAuth: true, // Skip auth to avoid infinite loop
+        });
+        (0, exports.setTokens)({
+            accessToken: response.accessToken,
+            refreshToken: response.refreshToken,
+        });
+        return response.accessToken;
+    }
+    catch (error) {
+        (0, exports.removeTokens)();
+        window.location.href = "/login";
+        throw error;
+    }
+};
+const buildUrl = (endpoint, query) => {
+    let url = `${BASE_URL}${endpoint}`;
+    if (query && Object.keys(query).length > 0) {
+        url += `?${qs_1.default.stringify(query, {
+            allowDots: true,
+            arrayFormat: "brackets",
+            allowEmptyArrays: false,
+            skipNulls: true,
+        })}`;
+    }
+    return url;
+};
 async function apiRequest(endpoint, options = {}) {
-    var _a;
+    var _a, _b, _c;
+    const tokens = (0, exports.getTokens)();
     const headers = {
         Accept: "application/json",
-        Authorization: `Bearer ${(0, utils_1.generateRandomBase64)(20)}`,
         "Content-Type": "application/json",
         ...options.headers,
     };
+    if (!options.skipAuth && (tokens === null || tokens === void 0 ? void 0 : tokens.accessToken)) {
+        headers.Authorization = `Bearer ${tokens.accessToken}`;
+    }
     const config = {
         method: (_a = options.method) !== null && _a !== void 0 ? _a : enums_1.HttpMethods.GET,
         headers,
-        // credentials: "include",
         ...options,
     };
-    options.method && options.method !== enums_1.HttpMethods.GET && console.log(config);
+    const logNonGetRequest = options.method && options.method !== enums_1.HttpMethods.GET;
+    if (logNonGetRequest) {
+        console.log("Request Config:", config);
+        console.log("Request URL:", buildUrl(endpoint, options.query));
+    }
     try {
-        options.method &&
-            options.method !== enums_1.HttpMethods.GET &&
-            console.log(`${BASE_URL}${endpoint}`);
-        let url = `${BASE_URL}${endpoint}`;
-        if (options.query && Object.keys(options.query).length > 0) {
-            console.log("Raw params ", options.query);
-            console.log("Stringified params = ", qs_1.default.stringify(options.query));
-            url += `?${qs_1.default.stringify(options.query, {
-                allowDots: true,
-                arrayFormat: "brackets",
-                allowEmptyArrays: false,
-                skipNulls: true,
-            })}`;
-        }
+        const url = buildUrl(endpoint, options.query);
         const response = await fetch(url, config);
-        // Parse the response once and store it
         const contentType = response.headers.get("content-type");
-        let responseData = contentType && contentType.includes("application/json")
+        const responseData = (contentType === null || contentType === void 0 ? void 0 : contentType.includes("application/json"))
             ? await response.json()
             : await response.text();
-        // Log for non-GET requests
-        options.method &&
-            options.method !== enums_1.HttpMethods.GET &&
-            console.log(responseData);
+        if (logNonGetRequest) {
+            console.log("Response Data:", responseData);
+        }
         if (!response.ok) {
             const error = new Error(typeof responseData === "object"
                 ? responseData.message || "API Error"
                 : "API Error");
             error.status = response.status;
             error.data = responseData;
-            if (response.status === enums_1.HttpStatusCodes.UNAUTHORIZED) {
-                // TODO: redirect to login page
+            // Handle token expired error
+            if (response.status === enums_1.HttpStatusCodes.UNAUTHORIZED &&
+                ((_b = responseData === null || responseData === void 0 ? void 0 : responseData.error) === null || _b === void 0 ? void 0 : _b.type) === "AUTHENTICATION_ERROR" &&
+                ((_c = responseData === null || responseData === void 0 ? void 0 : responseData.error) === null || _c === void 0 ? void 0 : _c.message) === "Token expired" &&
+                !options.skipAuth) {
+                if (isRefreshing) {
+                    // Wait for token refresh if already in progress
+                    return new Promise((resolve, reject) => {
+                        subscribeTokenRefresh(async (newToken) => {
+                            try {
+                                // Retry the original request with new token
+                                const retriedResponse = await apiRequest(endpoint, {
+                                    ...options,
+                                    headers: {
+                                        ...options.headers,
+                                        Authorization: `Bearer ${newToken}`,
+                                    },
+                                });
+                                resolve(retriedResponse);
+                            }
+                            catch (error) {
+                                reject(error);
+                            }
+                        });
+                    });
+                }
+                isRefreshing = true;
+                try {
+                    const newToken = await refreshTokens();
+                    onTokenRefreshed(newToken);
+                    isRefreshing = false;
+                    // Retry the original request with new token
+                    return apiRequest(endpoint, {
+                        ...options,
+                        headers: {
+                            ...options.headers,
+                            Authorization: `Bearer ${newToken}`,
+                        },
+                    });
+                }
+                catch (refreshError) {
+                    isRefreshing = false;
+                    throw refreshError;
+                }
             }
             throw error;
         }
-        // Return the already parsed response
         return responseData;
     }
     catch (error) {
-        console.log(error, "ERROR DATA---");
+        console.error("API Request Error:", error);
         return Promise.reject(error);
     }
 }

package/dist/features/auth/data/dto/AuthDTO.d.ts

@@ -0,0 +1,21 @@
+import { User } from "../../../models";
+export declare class RegisterDTO {
+    email: string;
+    password: string;
+    name?: string;
+    phone?: string;
+    static fromPlain(entity: any): RegisterDTO;
+    toPlain(): Record<string, unknown>;
+    validate(): string[];
+}
+export declare class LoginDTO {
+    email: string;
+    password: string;
+    static fromPlain(entity: any): LoginDTO;
+    toPlain(): Record<string, unknown>;
+    validate(): string[];
+}
+export declare class AuthResponseDTO {
+    user: User;
+    token: string;
+}

package/dist/features/auth/data/dto/AuthDTO.js

@@ -0,0 +1,68 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthResponseDTO = exports.LoginDTO = exports.RegisterDTO = void 0;
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+class RegisterDTO {
+    static fromPlain(entity) {
+        return (0, class_transformer_1.plainToClass)(RegisterDTO, entity);
+    }
+    toPlain() {
+        return (0, class_transformer_1.classToPlain)(this);
+    }
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+}
+__decorate([
+    (0, class_validator_1.IsEmail)(),
+    __metadata("design:type", String)
+], RegisterDTO.prototype, "email", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    (0, class_validator_1.MinLength)(8),
+    __metadata("design:type", String)
+], RegisterDTO.prototype, "password", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RegisterDTO.prototype, "name", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RegisterDTO.prototype, "phone", void 0);
+exports.RegisterDTO = RegisterDTO;
+class LoginDTO {
+    static fromPlain(entity) {
+        return (0, class_transformer_1.plainToClass)(LoginDTO, entity);
+    }
+    toPlain() {
+        return (0, class_transformer_1.classToPlain)(this);
+    }
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+}
+__decorate([
+    (0, class_validator_1.IsEmail)(),
+    __metadata("design:type", String)
+], LoginDTO.prototype, "email", void 0);
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], LoginDTO.prototype, "password", void 0);
+exports.LoginDTO = LoginDTO;
+class AuthResponseDTO {
+}
+exports.AuthResponseDTO = AuthResponseDTO;

package/dist/features/auth/data/dto/RoleDTO.d.ts

@@ -0,0 +1,37 @@
+import { User } from "../../../models";
+export declare class RoleGetDTO {
+    id: string;
+    name: string;
+    description?: string;
+    permissions: string[];
+    isActive: boolean;
+    createdAt: Date;
+    updatedAt: Date;
+    users?: User[];
+    static fromEntity(entity: any): RoleGetDTO;
+    toPlain(): Record<string, unknown>;
+}
+export declare class RoleCreateDTO {
+    name: string;
+    description?: string;
+    permissions: string[];
+    isActive?: boolean;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): RoleCreateDTO;
+    toPlain(): Record<string, unknown>;
+}
+export declare class RoleUpdateDTO {
+    name?: string;
+    description?: string;
+    permissions?: string[];
+    isActive?: boolean;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): RoleUpdateDTO;
+    toPlain(): Record<string, unknown>;
+}
+export declare class RolePermissionUpdateDTO {
+    permissions: string[];
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): RolePermissionUpdateDTO;
+    toPlain(): Record<string, unknown>;
+}

package/dist/features/auth/data/dto/RoleDTO.js

@@ -0,0 +1,119 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RolePermissionUpdateDTO = exports.RoleUpdateDTO = exports.RoleCreateDTO = exports.RoleGetDTO = void 0;
+const class_validator_1 = require("class-validator");
+const class_transformer_1 = require("class-transformer");
+class RoleGetDTO {
+    static fromEntity(entity) {
+        return (0, class_transformer_1.plainToClass)(RoleGetDTO, entity);
+    }
+    toPlain() {
+        return (0, class_transformer_1.classToPlain)(this);
+    }
+}
+exports.RoleGetDTO = RoleGetDTO;
+class RoleCreateDTO {
+    constructor() {
+        this.isActive = true;
+    }
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(RoleCreateDTO, plain);
+    }
+    toPlain() {
+        const plain = (0, class_transformer_1.classToPlain)(this);
+        // Add timestamps for creation
+        plain.createdAt = new Date();
+        plain.updatedAt = new Date();
+        return plain;
+    }
+}
+__decorate([
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RoleCreateDTO.prototype, "name", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RoleCreateDTO.prototype, "description", void 0);
+__decorate([
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.IsString)({ each: true }),
+    __metadata("design:type", Array)
+], RoleCreateDTO.prototype, "permissions", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], RoleCreateDTO.prototype, "isActive", void 0);
+exports.RoleCreateDTO = RoleCreateDTO;
+class RoleUpdateDTO {
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(RoleUpdateDTO, plain);
+    }
+    toPlain() {
+        const plain = (0, class_transformer_1.classToPlain)(this);
+        // Add updated timestamp
+        plain.updatedAt = new Date();
+        return plain;
+    }
+}
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RoleUpdateDTO.prototype, "name", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsString)(),
+    __metadata("design:type", String)
+], RoleUpdateDTO.prototype, "description", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.IsString)({ each: true }),
+    __metadata("design:type", Array)
+], RoleUpdateDTO.prototype, "permissions", void 0);
+__decorate([
+    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsBoolean)(),
+    __metadata("design:type", Boolean)
+], RoleUpdateDTO.prototype, "isActive", void 0);
+exports.RoleUpdateDTO = RoleUpdateDTO;
+class RolePermissionUpdateDTO {
+    validate() {
+        const errors = (0, class_validator_1.validateSync)(this);
+        return errors.map((error) => { var _a; return Object.values((_a = error.constraints) !== null && _a !== void 0 ? _a : {}); }).flat();
+    }
+    static fromPlain(plain) {
+        return (0, class_transformer_1.plainToClass)(RolePermissionUpdateDTO, plain);
+    }
+    toPlain() {
+        const plain = (0, class_transformer_1.classToPlain)(this);
+        plain.updatedAt = new Date();
+        return plain;
+    }
+}
+__decorate([
+    (0, class_validator_1.IsArray)(),
+    (0, class_validator_1.IsString)({ each: true }),
+    __metadata("design:type", Array)
+], RolePermissionUpdateDTO.prototype, "permissions", void 0);
+exports.RolePermissionUpdateDTO = RolePermissionUpdateDTO;

package/dist/features/auth/data/dto/UserDTO.d.ts

@@ -0,0 +1,40 @@
+import { Role } from "../../../models/Roles";
+export declare class UserGetDTO {
+    id: string;
+    refId: number;
+    email: string;
+    name?: string;
+    phone?: string;
+    photo?: string;
+    roles: Role[];
+    isActive: boolean;
+    lastLogin?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+    static fromEntity(entity: any): UserGetDTO;
+    toPlain(): Record<string, unknown>;
+}
+export declare class UserCreateDTO {
+    email?: string;
+    password: string;
+    name?: string;
+    phone: string;
+    photo?: string;
+    roleIds?: string[];
+    isActive?: boolean;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): UserCreateDTO;
+    toPlain(): Record<string, unknown>;
+}
+export declare class UserUpdateDTO {
+    password?: string;
+    name?: string;
+    phone?: string;
+    email?: string;
+    photo?: string;
+    roleIds?: string[];
+    isActive?: boolean;
+    validate(): string[];
+    static fromPlain(plain: Record<string, unknown>): UserUpdateDTO;
+    toPlain(): Record<string, unknown>;
+}