ldap-rest 0.0.1

package/dist/src/browser/ldap-user-editor/LdapUserEditor.d.ts

@@ -0,0 +1,32 @@
+/**
+ * LDAP User Editor - Main class
+ * @author Xavier Guimard
+ */
+import type { EditorOptions, Config, LdapUser } from './types';
+import { UserApiClient } from './api/UserApiClient';
+export declare class LdapUserEditor {
+    private options;
+    private api;
+    private container;
+    private userTree;
+    private userEditor;
+    private userList;
+    private currentUserDn;
+    private currentOrgDn;
+    private config;
+    constructor(options: EditorOptions);
+    init(): Promise<void>;
+    private render;
+    private initComponents;
+    private onOrganizationSelected;
+    private onUserSelected;
+    private handleError;
+    refresh(): Promise<void>;
+    destroy(): void;
+    createUser(userData: Partial<LdapUser>): Promise<LdapUser>;
+    deleteUser(dn: string): Promise<void>;
+    getConfig(): Config | null;
+    getApi(): UserApiClient;
+    getCurrentOrgDn(): string | null;
+    getCurrentUserDn(): string | null;
+}

package/dist/src/browser/ldap-user-editor/api/UserApiClient.d.ts

@@ -0,0 +1,55 @@
+/**
+ * LDAP User Editor - API Client
+ */
+import type { Config, LdapUser, PointerOption, Schema } from '../types';
+import { CacheManager } from '../cache/CacheManager';
+export declare class UserApiClient {
+    private baseUrl;
+    private cache;
+    constructor(baseUrl?: string, cacheOptions?: {
+        ttl?: number;
+        maxEntries?: number;
+    });
+    private getApiBase;
+    private getFirstValue;
+    /**
+     * Fetch with cache support for GET requests
+     */
+    private cachedFetch;
+    getConfig(): Promise<Config>;
+    getSchema(schemaUrl: string): Promise<Schema>;
+    getUsers(search?: string): Promise<LdapUser[]>;
+    getUser(dn: string): Promise<LdapUser>;
+    updateUser(dn: string, data: Partial<LdapUser>): Promise<LdapUser>;
+    createUser(data: Partial<LdapUser>): Promise<LdapUser>;
+    deleteUser(dn: string): Promise<void>;
+    moveUser(dn: string, targetOrgDn: string): Promise<{
+        success: boolean;
+        newDn?: string;
+    }>;
+    getPointerOptions(branch: string): Promise<PointerOption[]>;
+    /**
+     * Cache management methods
+     */
+    /**
+     * Clear all cache
+     */
+    clearCache(): void;
+    /**
+     * Invalidate cache for a specific URL pattern
+     */
+    invalidateCache(pattern: string): void;
+    /**
+     * Get cache statistics
+     */
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        ttl: number;
+        keys: string[];
+    };
+    /**
+     * Get cache instance (for advanced usage)
+     */
+    getCache(): CacheManager;
+}

package/dist/src/browser/ldap-user-editor/cache/CacheManager.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Simple in-memory cache manager with LRU eviction
+ * Prevents excessive API calls when navigating the organization tree
+ */
+export interface CacheOptions {
+    /**
+     * Time to live in milliseconds (default: 5 minutes)
+     */
+    ttl?: number;
+    /**
+     * Maximum number of entries (default: 200)
+     */
+    maxEntries?: number;
+}
+export declare class CacheManager {
+    private cache;
+    private ttl;
+    private maxEntries;
+    constructor(options?: CacheOptions);
+    /**
+     * Get an item from cache
+     * Returns null if not found or expired
+     */
+    get<T>(key: string): T | null;
+    /**
+     * Set an item in cache
+     * Evicts least recently used items if cache is full
+     */
+    set<T>(key: string, data: T): void;
+    /**
+     * Check if key exists and is not expired
+     */
+    has(key: string): boolean;
+    /**
+     * Invalidate a specific key
+     */
+    invalidate(key: string): void;
+    /**
+     * Invalidate all keys matching a pattern
+     * Pattern can contain wildcards (*)
+     */
+    invalidatePattern(pattern: string): void;
+    /**
+     * Clear all cache
+     */
+    clear(): void;
+    /**
+     * Get cache statistics
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        ttl: number;
+        keys: string[];
+    };
+    /**
+     * Evict least recently used entry
+     */
+    private evictLRU;
+    /**
+     * Clean expired entries
+     * Should be called periodically
+     */
+    cleanExpired(): number;
+}

package/dist/src/browser/ldap-user-editor/components/MoveUserModal.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LDAP User Editor - Move User Modal Component
+ * Modal dialog for selecting target organization when moving a user
+ */
+import type { UserApiClient } from '../api/UserApiClient';
+export declare class MoveUserModal {
+    private modal;
+    private api;
+    private currentOrgDn;
+    private selectedOrgDn;
+    private onMove;
+    private expandedNodes;
+    private rootDn;
+    constructor(api: UserApiClient, currentOrgDn: string, onMove: (targetOrgDn: string) => void);
+    /**
+     * Escape HTML special characters to prevent XSS attacks
+     */
+    private static escapeHtml;
+    show(): Promise<void>;
+    private attachHandlers;
+    private loadOrganizationTree;
+    private renderTree;
+    private renderNode;
+    private attachTreeHandlers;
+    private selectOrganization;
+    private handleMove;
+    close(): void;
+}

package/dist/src/browser/ldap-user-editor/components/PointerField.d.ts

@@ -0,0 +1,22 @@
+/**
+ * LDAP User Editor - Pointer Field Component
+ */
+import type { SchemaAttribute } from '../types';
+import type { UserApiClient } from '../api/UserApiClient';
+export declare class PointerField {
+    private api;
+    private attribute;
+    private fieldName;
+    private value;
+    private onChange;
+    private options;
+    constructor(api: UserApiClient, fieldName: string, attribute: SchemaAttribute, value: string | string[], onChange: (value: string | string[]) => void);
+    init(): Promise<void>;
+    private loadOptions;
+    render(): string;
+    private renderSingle;
+    private renderArray;
+    attachHandlers(container: HTMLElement): void;
+    private attachSingleHandlers;
+    private attachArrayHandlers;
+}

package/dist/src/browser/ldap-user-editor/components/UserEditor.d.ts

@@ -0,0 +1,46 @@
+/**
+ * LDAP User Editor - User Editor Component
+ */
+import type { UserApiClient } from '../api/UserApiClient';
+export declare class UserEditor {
+    private container;
+    private api;
+    private userDn;
+    private user;
+    private schema;
+    private formData;
+    private pointerFields;
+    private onSaved?;
+    private onDeleted?;
+    private ldapBase;
+    /**
+     * Escape HTML special characters to prevent XSS attacks
+     * Reference: https://cheatsheetseries.owasp.org/cheatsheets/DOM_based_XSS_Prevention_Cheat_Sheet.html
+     */
+    private static escapeHtml;
+    constructor(container: HTMLElement, api: UserApiClient, userDn: string, onSaved?: () => void, onDeleted?: () => void);
+    init(): Promise<void>;
+    private showLoading;
+    private showError;
+    private loadUserAndSchema;
+    private replacePlaceholders;
+    private getFirstValue;
+    private getFieldByRole;
+    private render;
+    private renderFormSections;
+    private renderField;
+    private renderIdentifierField;
+    private renderStringField;
+    private renderNumberField;
+    private renderArrayField;
+    private initPointerFields;
+    private rerenderPointerField;
+    private attachHandlers;
+    private attachArrayFieldHandlers;
+    private rerenderArrayField;
+    private handleSubmit;
+    private handleMove;
+    private performMove;
+    private handleDelete;
+    refresh(): Promise<void>;
+}

package/dist/src/browser/ldap-user-editor/components/UserList.d.ts

@@ -0,0 +1,24 @@
+/**
+ * LDAP User Editor - User List Component
+ * Shows users in a selected organization
+ */
+import type { UserApiClient } from '../api/UserApiClient';
+export declare class UserList {
+    private container;
+    private api;
+    private users;
+    private orgDn;
+    private searchQuery;
+    private onSelectUser;
+    private schema;
+    private config;
+    constructor(container: HTMLElement, api: UserApiClient, orgDn: string, onSelectUser: (dn: string) => void);
+    init(): Promise<void>;
+    private render;
+    private loadUsers;
+    private getFirstValue;
+    private getFieldNameByRole;
+    private getFieldValueByRole;
+    private renderUserList;
+    refresh(): Promise<void>;
+}

package/dist/src/browser/ldap-user-editor/components/UserTree.d.ts

@@ -0,0 +1,24 @@
+/**
+ * LDAP User Editor - Organization Tree Component
+ * Shows only LDAP organization tree (filters out users/groups)
+ */
+export declare class UserTree {
+    private container;
+    private baseUrl;
+    private onSelectOrg;
+    private expandedNodes;
+    private selectedDn;
+    private rootDn;
+    private cache;
+    constructor(container: HTMLElement, baseUrl: string, onSelectOrg: (dn: string) => void);
+    /**
+     * Fetch with cache support
+     */
+    private cachedFetch;
+    init(): Promise<void>;
+    private renderTree;
+    private renderNode;
+    private attachEventListeners;
+    refresh(): Promise<void>;
+    destroy(): void;
+}

package/dist/src/browser/ldap-user-editor/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LDAP User Editor - Browser library
+ * @author Xavier Guimard
+ */
+import './styles.css';
+export { LdapUserEditor } from './LdapUserEditor';
+export type { EditorOptions, LdapUser, Schema, SchemaAttribute, PointerOption, Config, } from './types';

package/dist/src/browser/ldap-user-editor/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * LDAP User Editor - Type definitions
+ */
+export interface EditorOptions {
+    containerId: string;
+    apiBaseUrl?: string;
+    onUserSaved?: (userDn: string) => void;
+    onError?: (error: Error) => void;
+}
+export interface LdapUser {
+    dn: string;
+    [key: string]: unknown;
+}
+export interface SchemaAttribute {
+    type: string;
+    required?: boolean;
+    fixed?: boolean;
+    role?: string;
+    test?: string;
+    branch?: string[];
+    items?: SchemaAttribute;
+    default?: unknown;
+    ui?: 'select' | 'search';
+    group?: string;
+}
+export interface Schema {
+    entity: {
+        name: string;
+        mainAttribute: string;
+        objectClass: string[];
+        singularName: string;
+        pluralName: string;
+        base: string;
+    };
+    strict: boolean;
+    attributes: Record<string, SchemaAttribute>;
+}
+export interface PointerOption {
+    dn: string;
+    label: string;
+}
+export interface FlatResourceConfig {
+    name: string;
+    singularName: string;
+    pluralName: string;
+    mainAttribute: string;
+    objectClass: string[];
+    base: string;
+    schema?: Schema;
+    schemaUrl?: string;
+    endpoints: {
+        list: string;
+        get: string;
+        create: string;
+        update: string;
+        delete: string;
+    };
+}
+export interface Config {
+    apiPrefix: string;
+    ldapBase: string;
+    features?: {
+        ldapFlatGeneric?: {
+            flatResources?: FlatResourceConfig[];
+        };
+    };
+}

package/dist/src/browser/shared/components/Modal.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Reusable Modal component
+ * @module browser/shared/components/Modal
+ */
+export interface ModalOptions {
+    id: string;
+    title: string;
+    onClose?: () => void;
+}
+export declare class Modal {
+    private overlay;
+    private options;
+    constructor(options: ModalOptions);
+    private attachEventListeners;
+    open(): void;
+    close(): void;
+    isOpen(): boolean;
+    getFormElement(): HTMLFormElement | null;
+    resetForm(): void;
+    setContent(html: string): void;
+    setTitle(title: string): void;
+    /**
+     * Create modal HTML structure
+     */
+    static createModalHTML(options: {
+        id: string;
+        title: string;
+        formId?: string;
+        submitLabel?: string;
+    }): string;
+    /**
+     * Create and inject modal into DOM
+     */
+    static create(options: ModalOptions & {
+        formId?: string;
+        submitLabel?: string;
+    }): Modal;
+}

package/dist/src/browser/shared/components/StatusMessage.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Status message component for displaying notifications
+ * @module browser/shared/components/StatusMessage
+ */
+export type StatusType = 'error' | 'success' | 'info' | 'warning';
+export interface StatusMessageOptions {
+    containerId: string;
+    duration?: number;
+    dismissible?: boolean;
+}
+export declare class StatusMessage {
+    private container;
+    private options;
+    private timeoutId;
+    constructor(options: StatusMessageOptions);
+    /**
+     * Show a status message
+     */
+    show(message: string, type?: StatusType): void;
+    /**
+     * Show error message
+     */
+    error(message: string): void;
+    /**
+     * Show success message
+     */
+    success(message: string): void;
+    /**
+     * Show info message
+     */
+    info(message: string): void;
+    /**
+     * Show warning message
+     */
+    warning(message: string): void;
+    /**
+     * Hide the status message
+     */
+    hide(): void;
+    /**
+     * Get the container element
+     */
+    getContainer(): HTMLElement | null;
+}
+/**
+ * Simple functional API for showing status messages
+ */
+export declare function showStatus(containerId: string, message: string, type?: StatusType, duration?: number): void;

package/dist/src/browser/shared/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Main export file for shared browser utilities and components
+ * @module browser/shared
+ */
+export * from './utils/dom';
+export * from './utils/form';
+export * from './utils/schema';
+export { Modal, type ModalOptions } from './components/Modal';
+export { StatusMessage, showStatus, type StatusMessageOptions, } from './components/StatusMessage';
+export * from './types';

package/dist/src/browser/shared/types/index.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Shared TypeScript types for browser components
+ * @module browser/shared/types
+ */
+export interface EditorConfig {
+    ldapBase?: string;
+    features?: {
+        flatResources?: ResourceConfig[];
+    };
+    [key: string]: unknown;
+}
+export interface ResourceConfig {
+    name: string;
+    pluralName?: string;
+    schemaUrl?: string;
+    schema?: SchemaDefinition;
+    base?: string;
+}
+export interface SchemaDefinition {
+    entity: {
+        objectClass?: string[];
+        base?: string;
+    };
+    attributes: Record<string, SchemaAttribute>;
+}
+export interface SchemaAttribute {
+    type: 'string' | 'number' | 'integer' | 'array' | 'pointer';
+    required?: boolean;
+    fixed?: boolean;
+    default?: unknown;
+    branch?: string[];
+    items?: {
+        type: string;
+        branch?: string[];
+    };
+    group?: string;
+}
+export interface PointerOption {
+    dn: string;
+    label: string;
+}
+export interface EditorAPI {
+    getPointerOptions(branch: string): Promise<PointerOption[]>;
+    createEntry(dn: string, data: Record<string, unknown>): Promise<void>;
+    deleteEntry(dn: string): Promise<void>;
+    updateEntry(dn: string, data: Record<string, unknown>): Promise<void>;
+}
+export interface BaseEditor {
+    getConfig(): EditorConfig;
+    getApi(): EditorAPI;
+    getCurrentOrgDn(): string | null;
+    getCurrentUserDn?(): string | null;
+    init(): Promise<void>;
+    createUser?(data: Record<string, unknown>): Promise<void>;
+    deleteUser?(dn: string): Promise<void>;
+}
+export type StatusType = 'error' | 'success' | 'info' | 'warning';
+export interface Theme {
+    name: string;
+    primaryColor: string;
+    primaryColorDark: string;
+    gradientStart: string;
+    gradientEnd: string;
+}
+export declare const THEMES: Record<string, Theme>;

package/dist/src/browser/shared/utils/dom.d.ts

@@ -0,0 +1,33 @@
+/**
+ * DOM utility functions
+ * @module browser/shared/utils/dom
+ */
+/**
+ * Escape HTML special characters to prevent XSS attacks
+ * Reference: https://cheatsheetseries.owasp.org/cheatsheets/DOM_based_XSS_Prevention_Cheat_Sheet.html
+ */
+export declare function escapeHtml(text: string | null | undefined): string;
+/**
+ * Convert camelCase or snake_case to Title Case
+ */
+export declare function toTitleCase(text: string): string;
+/**
+ * Create an HTML element with attributes and children
+ */
+export declare function createElement(tag: string, attributes?: Record<string, string>, children?: (string | HTMLElement)[]): HTMLElement;
+/**
+ * Set innerHTML safely (assumes content has been properly escaped)
+ */
+export declare function setInnerHTML(element: HTMLElement, html: string): void;
+/**
+ * Get element by ID with type safety
+ */
+export declare function getElementByIdSafe<T extends HTMLElement = HTMLElement>(id: string): T | null;
+/**
+ * Query selector with type safety
+ */
+export declare function querySelectorSafe<T extends HTMLElement = HTMLElement>(selector: string, parent?: Document | HTMLElement): T | null;
+/**
+ * Query selector all with type safety
+ */
+export declare function querySelectorAllSafe<T extends HTMLElement = HTMLElement>(selector: string, parent?: Document | HTMLElement): NodeListOf<T>;

package/dist/src/browser/shared/utils/form.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Form utility functions
+ * @module browser/shared/utils/form
+ */
+import type { SchemaAttribute, PointerOption } from '../types';
+/**
+ * Get user-friendly field label from field name
+ */
+export declare function getFieldLabel(fieldName: string, attribute?: SchemaAttribute, customLabels?: Record<string, string>): string;
+/**
+ * Generate HTML for a form field based on schema attribute
+ */
+export declare function generateFormField(fieldName: string, attribute: SchemaAttribute, options?: {
+    customLabels?: Record<string, string>;
+    pointerOptionsLoader?: (branch: string) => Promise<PointerOption[]>;
+}): Promise<string>;
+/**
+ * Process form data and convert types based on schema
+ */
+export declare function processFormData(formData: FormData, schema: Record<string, SchemaAttribute>): Record<string, unknown>;
+/**
+ * Collect values from pointer array fields
+ */
+export declare function collectPointerArrayValues(container: HTMLElement): Record<string, string[]>;
+/**
+ * Group schema fields by category
+ */
+export declare function groupSchemaFields(schema: Record<string, SchemaAttribute>, categorizer?: (fieldName: string, attribute: SchemaAttribute) => string | null): Map<string, [string, SchemaAttribute][]>;

package/dist/src/browser/shared/utils/schema.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Schema utility functions
+ * @module browser/shared/utils/schema
+ */
+import type { PointerOption } from '../types';
+/**
+ * Load pointer options from API
+ */
+export declare function loadPointerOptions(branch: string, apiLoader: (branch: string) => Promise<PointerOption[]>, useCache?: boolean): Promise<PointerOption[]>;
+/**
+ * Clear pointer options cache
+ */
+export declare function clearPointerOptionsCache(): void;
+/**
+ * Replace placeholders in schema branches
+ */
+export declare function replacePlaceholders(value: string | string[], replacements: Record<string, string>): string | string[];
+/**
+ * Replace placeholders in schema attributes
+ */
+export declare function replaceSchemaPlaceholders<T extends Record<string, unknown>>(schema: T, replacements: Record<string, string>): T;
+/**
+ * Fetch organization path from API
+ */
+export declare function getOrganizationPath(orgDn: string, apiBaseUrl: string): Promise<string>;
+/**
+ * Load schema from URL or object
+ */
+export declare function loadSchema<T = unknown>(schemaSource: string | T): Promise<T>;