@zerosls/clm-sdk 1.0.0

package/dist/modules/v1/users/users-api.d.ts

@@ -0,0 +1,81 @@
+import { ApiClient } from '../../../core/api-client';
+import { RequestOptions } from '../../../types/common';
+import { User, UsersResponse, UsersQuery, UserCreate, UserUpdate, UserCreatedResponse, UserUpdatedResponse, UserDeletedResponse, UserDeactivatedResponse } from './types';
+export declare class UsersApi {
+    private apiClient;
+    private readonly CACHE_PREFIX;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get all users with optional filters and pagination
+     *
+     * @param query - Query parameters for filtering and pagination
+     * @param options - Request options
+     * @returns Paginated list of users
+     */
+    getAll(query?: UsersQuery, options?: RequestOptions): Promise<UsersResponse>;
+    /**
+     * Get a specific user by ID
+     *
+     * @param id - User ID (UUID)
+     * @param showDeleted - Whether to include deleted users
+     * @param options - Request options
+     * @returns User data
+     */
+    getById(id: string, showDeleted?: boolean, options?: RequestOptions): Promise<User>;
+    /**
+     * Create a new user
+     *
+     * @param userData - User data for creation
+     * @param options - Request options
+     * @returns Created user response
+     */
+    create(userData: UserCreate, options?: RequestOptions): Promise<UserCreatedResponse>;
+    /**
+     * Update an existing user
+     *
+     * @param id - User ID (UUID)
+     * @param userData - Data to update
+     * @param options - Request options
+     * @returns Updated user response
+     */
+    update(id: string, userData: UserUpdate, options?: RequestOptions): Promise<UserUpdatedResponse>;
+    /**
+     * Permanently delete a user
+     *
+     * @param id - User ID (UUID)
+     * @param options - Request options
+     * @returns Delete confirmation response
+     */
+    delete(id: string, options?: RequestOptions): Promise<UserDeletedResponse>;
+    /**
+     * Deactivate a user (soft delete)
+     *
+     * @param id - User ID (UUID)
+     * @param options - Request options
+     * @returns Deactivated user response
+     */
+    deactivate(id: string, options?: RequestOptions): Promise<UserDeactivatedResponse>;
+    /**
+     * Search users by email or name
+     * Helper method that uses getAll with specific filters
+     *
+     * @param searchTerm - Term to search for in email or name
+     * @param options - Request options
+     * @returns Matching users
+     */
+    search(searchTerm: string, options?: RequestOptions): Promise<UsersResponse>;
+    /**
+     * Get users by role ID
+     * Helper method that uses getAll with role filter
+     *
+     * @param roleId - Role ID to filter by
+     * @param options - Request options
+     * @returns Users with the specified role
+     */
+    getByRole(roleId: number, options?: RequestOptions): Promise<UsersResponse>;
+    /**
+     * Clear cache for users
+     * Private method used internally after modifications
+     */
+    private clearCache;
+}

package/dist/modules/v1/users/users-api.js

@@ -0,0 +1,113 @@
+export class UsersApi {
+    constructor(apiClient) {
+        this.CACHE_PREFIX = 'GET:/users';
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get all users with optional filters and pagination
+     *
+     * @param query - Query parameters for filtering and pagination
+     * @param options - Request options
+     * @returns Paginated list of users
+     */
+    async getAll(query, options) {
+        const allUsers = this.apiClient.get('/users', query, options);
+        console.log(allUsers);
+        return allUsers;
+    }
+    /**
+     * Get a specific user by ID
+     *
+     * @param id - User ID (UUID)
+     * @param showDeleted - Whether to include deleted users
+     * @param options - Request options
+     * @returns User data
+     */
+    async getById(id, showDeleted = false, options) {
+        return this.apiClient.get(`/users/${id}`, { showDeleted }, options);
+    }
+    /**
+     * Create a new user
+     *
+     * @param userData - User data for creation
+     * @param options - Request options
+     * @returns Created user response
+     */
+    async create(userData, options) {
+        return this.apiClient.post('/users', userData, options);
+    }
+    /**
+     * Update an existing user
+     *
+     * @param id - User ID (UUID)
+     * @param userData - Data to update
+     * @param options - Request options
+     * @returns Updated user response
+     */
+    async update(id, userData, options) {
+        return this.apiClient.patch(`/users/${id}`, userData, options);
+    }
+    /**
+     * Permanently delete a user
+     *
+     * @param id - User ID (UUID)
+     * @param options - Request options
+     * @returns Delete confirmation response
+     */
+    async delete(id, options) {
+        return this.apiClient.delete(`/users/${id}`, undefined, options);
+    }
+    /**
+     * Deactivate a user (soft delete)
+     *
+     * @param id - User ID (UUID)
+     * @param options - Request options
+     * @returns Deactivated user response
+     */
+    async deactivate(id, options) {
+        return this.apiClient.patch(`/users/${id}/desactivate`, undefined, options);
+    }
+    /**
+     * Search users by email or name
+     * Helper method that uses getAll with specific filters
+     *
+     * @param searchTerm - Term to search for in email or name
+     * @param options - Request options
+     * @returns Matching users
+     */
+    async search(searchTerm, options) {
+        // Determine if searchTerm looks like an email
+        const isEmail = searchTerm.includes('@');
+        const query = isEmail
+            ? { email: searchTerm }
+            : { full_name: searchTerm };
+        return this.getAll(query, options);
+    }
+    /**
+     * Get users by role ID
+     * Helper method that uses getAll with role filter
+     *
+     * @param roleId - Role ID to filter by
+     * @param options - Request options
+     * @returns Users with the specified role
+     */
+    async getByRole(roleId, options) {
+        return this.getAll({ role_id: roleId }, options);
+    }
+    /**
+     * Clear cache for users
+     * Private method used internally after modifications
+     */
+    clearCache() {
+        try {
+            // @ts-ignore - This works because the SDK has a cache.clearByPrefix method
+            if (this.apiClient['cache'] && typeof this.apiClient['cache'].clearByPrefix === 'function') {
+                // @ts-ignore
+                this.apiClient['cache'].clearByPrefix(this.CACHE_PREFIX);
+            }
+        }
+        catch (error) {
+            console.error('Error clearing cache:', error);
+        }
+    }
+}

package/dist/types/common.d.ts

@@ -0,0 +1,18 @@
+export interface PaginatedResponse<T> {
+    results: T[];
+    pagination: {
+        page: number;
+        limit: number;
+        totalPages: number;
+        totalItems: number;
+    };
+}
+export interface RequestOptions {
+    useCache?: boolean;
+    cacheTime?: number;
+    headers?: Record<string, string>;
+}
+export interface PaginationParams {
+    page?: number;
+    limit?: number;
+}

package/dist/types/common.js

@@ -0,0 +1 @@
+export {};

package/dist/types/sdk.d.ts

@@ -0,0 +1,42 @@
+export interface SdkConfig {
+    baseUrl: string;
+    organization: string;
+    token?: string | null;
+    cache?: {
+        enabled?: boolean;
+        ttl?: number;
+    };
+    debug?: boolean;
+}
+export type SdkEventType = "tokenChanged" | "beforeRequest" | "afterRequest" | "requestError" | "authError";
+export interface SdkEvents {
+    tokenChanged: string | null;
+    beforeRequest: {
+        url: string;
+        method: string;
+        data?: any;
+    };
+    afterRequest: {
+        url: string;
+        method: string;
+        response: any;
+    };
+    requestError: {
+        url: string;
+        method: string;
+        error: any;
+    };
+    authError: {
+        statusCode: number;
+        message: string;
+    };
+}
+export declare enum ErrorType {
+    NETWORK = "NETWORK",
+    AUTHENTICATION = "AUTHENTICATION",
+    AUTHORIZATION = "AUTHORIZATION",
+    NOT_FOUND = "NOT_FOUND",
+    VALIDATION = "VALIDATION",
+    SERVER = "SERVER",
+    UNKNOWN = "UNKNOWN"
+}

package/dist/types/sdk.js

@@ -0,0 +1,11 @@
+// Tipos de errores HTTP
+export var ErrorType;
+(function (ErrorType) {
+    ErrorType["NETWORK"] = "NETWORK";
+    ErrorType["AUTHENTICATION"] = "AUTHENTICATION";
+    ErrorType["AUTHORIZATION"] = "AUTHORIZATION";
+    ErrorType["NOT_FOUND"] = "NOT_FOUND";
+    ErrorType["VALIDATION"] = "VALIDATION";
+    ErrorType["SERVER"] = "SERVER";
+    ErrorType["UNKNOWN"] = "UNKNOWN";
+})(ErrorType || (ErrorType = {}));

package/dist/utils/cache.d.ts

@@ -0,0 +1,10 @@
+export declare class Cache {
+    private store;
+    private defaultTtl;
+    constructor(defaultTtl?: number);
+    set<T>(key: string, data: T, ttl?: number): void;
+    get<T>(key: string): T | null;
+    delete(key: string): void;
+    clearByPrefix(prefix: string): void;
+    clear(): void;
+}

package/dist/utils/cache.js

@@ -0,0 +1,43 @@
+export class Cache {
+    constructor(defaultTtl = 60000) {
+        this.store = new Map();
+        this.defaultTtl = defaultTtl;
+    }
+    // Guardar dato en caché
+    set(key, data, ttl) {
+        const expiry = ttl || this.defaultTtl;
+        this.store.set(key, {
+            data,
+            timestamp: Date.now(),
+            expiry
+        });
+    }
+    // Obtener dato desde caché
+    get(key) {
+        const item = this.store.get(key);
+        // Si no existe o está expirado, devolver null
+        if (!item || Date.now() > item.timestamp + item.expiry) {
+            if (item) {
+                this.store.delete(key); // Limpiar item expirado
+            }
+            return null;
+        }
+        return item.data;
+    }
+    // Eliminar dato específico
+    delete(key) {
+        this.store.delete(key);
+    }
+    // Limpiar caché por prefijo
+    clearByPrefix(prefix) {
+        for (const key of this.store.keys()) {
+            if (key.startsWith(prefix)) {
+                this.store.delete(key);
+            }
+        }
+    }
+    // Limpiar toda la caché
+    clear() {
+        this.store.clear();
+    }
+}

package/dist/utils/http.d.ts

@@ -0,0 +1,5 @@
+export declare function buildUrl(baseUrl: string, endpoint: string, params?: Record<string, any>): string;
+export declare function buildHeaders(token?: string | null, customHeaders?: Record<string, string>): Headers;
+export declare function generateCacheKey(method: string, url: string, data?: any): string;
+export declare function parseResponse<T>(response: Response): Promise<T>;
+export declare function buildQueryParams(params: object | null): string;

package/dist/utils/http.js

@@ -0,0 +1,56 @@
+// import { RequestOptions } from "../types/common";
+// Construye URL con parámetros query
+export function buildUrl(baseUrl, endpoint, params) {
+    const url = new URL(`${baseUrl}${endpoint}`);
+    if (params) {
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                url.searchParams.append(key, String(value));
+            }
+        });
+    }
+    return url.toString();
+}
+// Construye cabeceras HTTP
+export function buildHeaders(token, customHeaders) {
+    const headers = new Headers({
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...customHeaders,
+    });
+    if (token && !headers.get("Authorization")) {
+        headers.append("Authorization", `Bearer ${token}`);
+    }
+    return headers;
+}
+// Genera una clave de caché única para cada petición
+export function generateCacheKey(method, url, data) {
+    const dataString = data ? JSON.stringify(data) : "";
+    return `${method}:${url}:${dataString}`;
+}
+// Parse respuesta JSON con manejo de errores
+export async function parseResponse(response) {
+    const responseText = await response.text();
+    try {
+        // Si no hay contenido, devolver objeto vacío
+        if (response.status === 204) {
+            return {};
+        }
+        // Intentar parsear como JSON
+        const data = JSON.parse(responseText);
+        return data;
+    }
+    catch (error) {
+        return responseText;
+    }
+}
+export function buildQueryParams(params) {
+    if (!params)
+        return "";
+    const queryParams = Object.entries(params)
+        .filter((line) => Boolean(line[1]))
+        .map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(value)}`);
+    if (queryParams.length === 0)
+        return "";
+    return "?" + queryParams.join("&");
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@zerosls/clm-sdk",
+  "version": "1.0.0",
+  "description": "SDK for ZeroCLM API",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint src/**/*.ts",
+    "prepublish": "npm run build",
+    "prepare": "npm run build",
+    "dev": "tsc --watch --preserveWatchOutput",
+    "link-dev": "npm run build && npm link"
+  },
+  "keywords": [
+    "clm",
+    "api",
+    "sdk"
+  ],
+  "author": "devcervant",
+  "license": "MIT",
+  "dependencies": {
+    "tslib": "^2.5.0"
+  },
+  "devDependencies": {
+    "@types/node": "^18.16.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.1",
+    "@typescript-eslint/parser": "^5.59.1",
+    "@vitest/coverage-c8": "^0.32.0",
+    "eslint": "^8.39.0",
+    "jsdom": "^22.0.0",
+    "typescript": "^5.0.4",
+    "vitest": "^0.32.0"
+  }
+}

package/src/config/config.ts

@@ -0,0 +1,24 @@
+import { SdkConfig } from "../types/sdk";
+
+// Valores por defecto para la configuración
+export const DEFAULT_CONFIG: Partial<SdkConfig> = {
+  baseUrl: "https://api.clm-app.com/api",
+  organization: "default-org",
+  cache: {
+    enabled: true,
+    ttl: 60000, // 1 minuto
+  },
+  debug: true,
+};
+
+// Función para combinar configuración del usuario con valores por defecto
+export function mergeWithDefaultConfig(config: Partial<SdkConfig>): SdkConfig {
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    cache: {
+      ...DEFAULT_CONFIG.cache,
+      ...(config.cache || {}), // Usar un objeto vacío si config.cache es undefined
+    },
+  } as SdkConfig;
+}