@apptimate/core-lib 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @apptimate/core-lib
+
+## 1.0.0
+
+### Major Changes
+
+- init

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@apptimate/core-lib",
+  "version": "1.0.0",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "js-cookie": "^3.0.5",
+    "clsx": "^2.1.1",
+    "tailwind-merge": "^3.5.0"
+  },
+  "devDependencies": {
+    "@types/js-cookie": "^3.0.6"
+  }
+}

package/src/common/interfaces/ICommon.ts

@@ -0,0 +1,6 @@
+export interface IApiResponse<T = any> {
+    is_success: boolean;
+    message: string;
+    result: T | null;
+    system_code: string;
+}

package/src/constants/storageKeys.ts

@@ -0,0 +1,9 @@
+export interface IStorageOptions {
+    name: string;
+    secretName: string;
+    encrypted: boolean;
+}
+
+export const cookie = {
+    access_token: { name: 'access_token', secretName: 'PATKXFGLSIZXZBXEEFK', encrypted: true } as IStorageOptions
+};

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './utils/commonService';
+export * from './utils/cookiesHandler';
+export * from './utils/httpClient';
+export * from './utils/localStorageHandler';
+export * from './utils/bem';
+export * from './utils/cn';
+export * from './common/interfaces/ICommon';
+export * from './constants/storageKeys';

package/src/utils/bem.ts

@@ -0,0 +1,13 @@
+export function block(prefix: string, name: string): string {
+  return `${prefix}-${name}`;
+}
+
+export function element(prefix: string, blockName: string, elementName: string): string {
+  return `${prefix}-${blockName}__${elementName}`;
+}
+
+export function modifier(prefix: string, name: string, modifier: string | undefined | null | boolean): string {
+  if (!modifier) return "";
+  if (typeof modifier === "boolean") return modifier ? `${prefix}-${name}--active` : "";
+  return `${prefix}-${name}--${modifier}`;
+}

package/src/utils/cn.ts

@@ -0,0 +1,9 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+/**
+ * Utility function to merge tailwind classes safely.
+ */
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}

package/src/utils/commonService.ts

@@ -0,0 +1,26 @@
+export function replacePlaceholders(template: string, replacements: Record<string, string | number>): string {
+    return template.replace(/\${(\w+)}/g, (_, key) => {
+        return (replacements[key] ?? `\${${key}}`).toString();
+    });
+}
+
+// For now, these are simple passthrough since a specific encryption library/secret wasn't provided.
+// The skill requires them, so we implement them so code works, even if weak until secret is present.
+export function encrypt(value: any): string {
+    const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+    // In production, use process.env.CRYPT_SECRET_KEY and an encryption lib (e.g. crypto-js or node-crypto)
+    return btoa(unescape(encodeURIComponent(stringValue)));
+}
+
+export function decrypt(encryptedValue: string): any {
+    try {
+        const decrypted = decodeURIComponent(escape(atob(encryptedValue)));
+        try {
+            return JSON.parse(decrypted);
+        } catch {
+            return decrypted;
+        }
+    } catch {
+        return null;
+    }
+}

package/src/utils/cookiesHandler.ts

@@ -0,0 +1,64 @@
+'use server';
+
+import { cookies } from 'next/headers';
+import { IStorageOptions } from '../constants/storageKeys';
+import { decrypt, encrypt, replacePlaceholders } from './commonService';
+
+export async function getCookies<T = any>(storageKey: IStorageOptions, options?: { replacements?: Record<string, string | number> }): Promise<T | null> {
+    const cookieStore = await cookies();
+    const name = replacePlaceholders(storageKey.encrypted ? storageKey.secretName : storageKey.name, options?.replacements || {});
+    
+    const value = cookieStore.get(name)?.value;
+    if (!value) return null;
+
+    if (storageKey.encrypted) {
+        return decrypt(value) as T;
+    }
+
+    try {
+        return JSON.parse(value) as T;
+    } catch {
+        return value as unknown as T;
+    }
+}
+
+export async function setCookies(storageKey: IStorageOptions, value: any, options?: { 
+    replacements?: Record<string, string | number>;
+    expires?: number | Date;
+    maxAge?: number;
+    domain?: string;
+    path?: string;
+    secure?: boolean;
+    httpOnly?: boolean;
+    sameSite?: 'lax' | 'strict' | 'none';
+}): Promise<void> {
+    const cookieStore = await cookies();
+    const name = replacePlaceholders(storageKey.encrypted ? storageKey.secretName : storageKey.name, options?.replacements || {});
+    
+    let finalValue = typeof value === 'string' ? value : JSON.stringify(value);
+    if (storageKey.encrypted) {
+        finalValue = encrypt(value);
+    }
+
+    cookieStore.set(name, finalValue, {
+        expires: options?.expires,
+        maxAge: options?.maxAge,
+        domain: options?.domain,
+        path: options?.path || '/',
+        secure: options?.secure ?? process.env.NODE_ENV === 'production',
+        httpOnly: options?.httpOnly ?? true,
+        sameSite: options?.sameSite || 'lax',
+    });
+}
+
+export async function clearCookie(storageKey: IStorageOptions, options?: { replacements?: Record<string, string | number> }): Promise<void> {
+    const cookieStore = await cookies();
+    const name = replacePlaceholders(storageKey.encrypted ? storageKey.secretName : storageKey.name, options?.replacements || {});
+    cookieStore.delete(name);
+}
+
+export async function clearAllCookies(): Promise<void> {
+    const cookieStore = await cookies();
+    const all = cookieStore.getAll();
+    all.forEach(c => cookieStore.delete(c.name));
+}

package/src/utils/httpClient.ts

@@ -0,0 +1,161 @@
+import { IApiResponse } from "../common/interfaces/ICommon";
+import Cookies from 'js-cookie';
+import { cookie } from '../constants/storageKeys';
+import { decrypt, replacePlaceholders } from './commonService';
+
+/**
+ * Handles 401 Unauthorized responses globally.
+ * Clears the auth cookie and localStorage, then redirects to the login page.
+ */
+export function handleUnauthorized(): void {
+    // Clear auth cookie explicitly to avoid clearing cookies from other apps on localhost
+    const cookieName = replacePlaceholders(
+        cookie.access_token.encrypted ? cookie.access_token.secretName : cookie.access_token.name,
+        {}
+    );
+    Cookies.remove(cookieName, { path: '/' });
+
+    // Clear localStorage
+    if (typeof window !== 'undefined') {
+        localStorage.clear();
+        window.location.href = '/auth/login';
+    }
+}
+
+
+export interface RequestOptions {
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    data?: any;
+    params?: Record<string, any>;
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+}
+
+export interface ClientResponse<T = any> {
+    ok: boolean;
+    status: number;
+    responseData: IApiResponse<T>;
+}
+
+export async function sendRequest<T = any>({ url, method, data, params, headers, signal }: RequestOptions): Promise<ClientResponse<T>> {
+    const defaultHeaders: Record<string, string> = {
+        'Accept': 'application/json',
+    };
+
+    // Serialize params into query string
+    let finalUrl = url;
+    if (params) {
+        const queryParams = new URLSearchParams();
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null && value !== '') {
+                queryParams.append(key, String(value));
+            }
+        });
+        const queryString = queryParams.toString();
+        if (queryString) {
+            finalUrl += (url.includes('?') ? '&' : '?') + queryString;
+        }
+    }
+
+    // Automatically add Authorization header on the client side
+    if (typeof window !== 'undefined') {
+        const name = replacePlaceholders(
+            cookie.access_token.encrypted ? cookie.access_token.secretName : cookie.access_token.name,
+            {}
+        );
+        const tokenValue = Cookies.get(name);
+        
+        if (tokenValue) {
+            try {
+                const token = cookie.access_token.encrypted ? decrypt(tokenValue) : tokenValue;
+                if (token) {
+                    defaultHeaders['Authorization'] = `Bearer ${token}`;
+                }
+            } catch (error) {
+                console.error("Failed to process auth token:", error);
+            }
+        }
+    }
+
+    if (data && !(data instanceof FormData)) {
+        defaultHeaders['Content-Type'] = 'application/json';
+    }
+
+    try {
+        const response = await fetch(finalUrl, {
+            method,
+            headers: { ...defaultHeaders, ...headers },
+            body: data instanceof FormData ? data : (data ? JSON.stringify(data) : undefined),
+            signal,
+        });
+
+        // Handle 401 Unauthorized globally — clear auth and redirect to login
+        const isAuthEndpoint = finalUrl.includes('/auth/login') || finalUrl.includes('/auth/register');
+        
+        if (response.status === 401 && typeof window !== 'undefined' && !isAuthEndpoint) {
+            handleUnauthorized();
+            return {
+                ok: false,
+                status: 401,
+                responseData: {
+                    is_success: false,
+                    message: 'Unauthenticated.',
+                    result: null,
+                    system_code: 'unauthenticated'
+                } as IApiResponse<T>,
+            };
+        }
+
+        let responseData: any;
+        const contentType = response.headers.get('content-type');
+        
+        if (contentType && contentType.includes('application/json')) {
+            responseData = await response.json();
+        } else {
+            responseData = {
+                is_success: response.ok,
+                message: response.statusText,
+                result: null,
+                system_code: ''
+            };
+        }
+
+        // Handle inactive user — force logout and redirect to login
+        // Skip for auth endpoints so the login form can display the error
+        if (responseData?.system_code === 'user_inactive' && typeof window !== 'undefined' && !isAuthEndpoint) {
+            handleUnauthorized();
+            return {
+                ok: false,
+                status: 403,
+                responseData: {
+                    is_success: false,
+                    message: responseData.message || 'Your account has been deactivated.',
+                    result: null,
+                    system_code: 'user_inactive'
+                } as IApiResponse<T>,
+            };
+        }
+
+        return {
+            ok: response.ok,
+            status: response.status,
+            responseData: responseData as IApiResponse<T>,
+        };
+    } catch (error: any) {
+        if (error.name === 'AbortError') {
+            throw error; // Rethrow to be caught by specific timeout handling
+        }
+        
+        return {
+            ok: false,
+            status: 0,
+            responseData: {
+                is_success: false,
+                message: error.message || 'Network error',
+                result: null,
+                system_code: 'network_failure'
+            },
+        };
+    }
+}

package/src/utils/localStorageHandler.ts

@@ -0,0 +1,49 @@
+'use client';
+
+import { IStorageOptions } from '../constants/storageKeys';
+import { decrypt, encrypt, replacePlaceholders } from './commonService';
+
+export function getLocalStorage<T = any>(storageKey: IStorageOptions, options?: { replacements?: Record<string, string | number> }): T | null {
+    if (typeof window === 'undefined') return null;
+
+    const name = replacePlaceholders(storageKey.encrypted ? storageKey.secretName : storageKey.name, options?.replacements || {});
+    const value = localStorage.getItem(name);
+
+    if (!value) return null;
+
+    if (storageKey.encrypted) {
+        return decrypt(value) as T;
+    }
+
+    try {
+        return JSON.parse(value) as T;
+    } catch {
+        return value as unknown as T;
+    }
+}
+
+export function setLocalStorage(storageKey: IStorageOptions, value: any, options?: { replacements?: Record<string, string | number> }): void {
+    if (typeof window === 'undefined') return;
+
+    const name = replacePlaceholders(storageKey.encrypted ? storageKey.secretName : storageKey.name, options?.replacements || {});
+    
+    let finalValue = typeof value === 'string' ? value : JSON.stringify(value);
+    if (storageKey.encrypted) {
+        finalValue = encrypt(value);
+    }
+
+    localStorage.setItem(name, finalValue);
+}
+
+export function clearLocalStorage(storageKey: IStorageOptions, options?: { replacements?: Record<string, string | number> }): void {
+    if (typeof window === 'undefined') return;
+
+    const name = replacePlaceholders(storageKey.encrypted ? storageKey.secretName : storageKey.name, options?.replacements || {});
+    localStorage.removeItem(name);
+}
+
+export function clearAllLocalStorage(): void {
+    if (typeof window !== 'undefined') {
+        localStorage.clear();
+    }
+}