ldap-rest 0.0.1

package/dist/src/browser/ldap-group-editor/components/MoveGroupModal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Move Group Modal Component - Modal for selecting target organization when moving a group
+ */
+import type { GroupApiClient } from '../api/GroupApiClient';
+export declare class MoveGroupModal {
+    private api;
+    private currentOrgDn;
+    private onMove;
+    private modal;
+    private expandedNodes;
+    private selectedOrgDn;
+    constructor(api: GroupApiClient, currentOrgDn: string, onMove: (targetOrgDn: string) => Promise<void>);
+    show(): Promise<void>;
+    private loadOrgTree;
+    private renderNode;
+    private attachTreeEventListeners;
+    private handleConfirm;
+    private close;
+    private escapeHtml;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * LDAP Group Editor - Entry point
+ * @author Xavier Guimard
+ */
+export { LdapGroupEditor } from './LdapGroupEditor.js';
+export type { GroupEditorOptions, Config, LdapGroup } from './types.js';

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

@@ -0,0 +1,58 @@
+/**
+ * TypeScript types for LDAP Group Editor
+ */
+export interface GroupEditorOptions {
+    containerId: string;
+    apiBaseUrl?: string;
+    onGroupSaved?: (groupDn: string) => void;
+    onError?: (error: Error) => void;
+}
+export interface Config {
+    ldapBase: string;
+    features?: {
+        flatResources?: ResourceConfig[];
+        ldapFlatGeneric?: {
+            flatResources?: ResourceConfig[];
+        };
+        ldapGroups?: {
+            schemaUrl?: string;
+            schema?: SchemaDefinition;
+        };
+    };
+    [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 LdapGroup {
+    dn: string;
+    cn: string;
+    description?: string;
+    member?: string[];
+    owner?: string[];
+    mail?: string;
+    [key: string]: unknown;
+}

package/dist/src/browser/ldap-resource-editor/api/ResourceApiClient.d.ts

@@ -0,0 +1,53 @@
+/**
+ * LDAP Resource Editor - Generic API Client
+ */
+import type { Config, LdapResource, PointerOption, Schema, ResourceType } from '../types';
+import { CacheManager } from '../cache/CacheManager';
+export declare class ResourceApiClient {
+    private baseUrl;
+    private cache;
+    private resourceType;
+    constructor(resourceType: ResourceType, baseUrl?: string, cacheOptions?: {
+        ttl?: number;
+        maxEntries?: number;
+    });
+    private getApiBase;
+    private getResourceEndpoint;
+    private getFirstValue;
+    /**
+     * Fetch with cache support for GET requests
+     */
+    private cachedFetch;
+    getConfig(): Promise<Config>;
+    getSchema(schemaUrl: string): Promise<Schema>;
+    getResources(search?: string): Promise<LdapResource[]>;
+    getResource(dn: string): Promise<LdapResource>;
+    updateResource(dn: string, data: Partial<LdapResource>): Promise<LdapResource>;
+    createResource(data: Partial<LdapResource>): Promise<LdapResource>;
+    deleteResource(dn: string): Promise<void>;
+    /**
+     * Create a generic entry (for organizations tree navigation)
+     */
+    createEntry(dn: string, data: Partial<LdapResource>): Promise<LdapResource>;
+    /**
+     * Delete a generic entry (for organizations)
+     */
+    deleteEntry(dn: string): Promise<void>;
+    getPointerOptions(branch: string): Promise<PointerOption[]>;
+    /**
+     * Get main attribute for this resource type
+     */
+    private getMainAttribute;
+    /**
+     * Cache management methods
+     */
+    clearCache(): void;
+    invalidateCache(pattern: string): void;
+    getCacheStats(): {
+        size: number;
+        maxSize: number;
+        ttl: number;
+        keys: string[];
+    };
+    getCache(): CacheManager;
+}

package/dist/src/browser/ldap-resource-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-resource-editor/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * LDAP Resource Editor - Generic browser library
+ * @author Xavier Guimard
+ */
+export { ResourceApiClient } from './api/ResourceApiClient';
+export type { EditorOptions, LdapResource, Schema, SchemaAttribute, PointerOption, Config, ResourceType, NavigationType, ResourceTypeConfig, } from './types';

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

@@ -0,0 +1,78 @@
+/**
+ * LDAP Resource Editor - Generic Type Definitions
+ */
+export type ResourceType = 'users' | 'groups' | 'organizations';
+export type NavigationType = 'flat' | 'tree';
+export interface EditorOptions {
+    containerId: string;
+    resourceType: ResourceType;
+    apiBaseUrl?: string;
+    navigationType?: NavigationType;
+    onResourceSaved?: (resourceDn: string) => void;
+    onError?: (error: Error) => void;
+}
+export interface LdapResource {
+    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?: {
+        flatResources?: FlatResourceConfig[];
+        ldapFlatGeneric?: {
+            flatResources?: FlatResourceConfig[];
+        };
+    };
+}
+export interface ResourceTypeConfig {
+    singularName: string;
+    pluralName: string;
+    icon: string;
+    emptyStateMessage: string;
+}

package/dist/src/browser/ldap-tree-viewer/LdapTreeViewer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Main LdapTreeViewer class
+ */
+import type { ViewerOptions, TreeState } from './types';
+export declare class LdapTreeViewer {
+    private options;
+    private store;
+    private api;
+    private container;
+    private rootComponent;
+    private unsubscribe?;
+    constructor(options: ViewerOptions);
+    init(): Promise<void>;
+    private render;
+    private handleNodeToggle;
+    private loadChildren;
+    private handleNodeClick;
+    private transformToTreeNode;
+    private detectNodeType;
+    expandNode(dn: string): Promise<void>;
+    collapseNode(dn: string): Promise<void>;
+    refresh(): Promise<void>;
+    selectNode(dn: string | null): void;
+    getState(): TreeState;
+    destroy(): void;
+}

package/dist/src/browser/ldap-tree-viewer/api/LdapApiClient.d.ts

@@ -0,0 +1,30 @@
+/**
+ * LDAP API Client for browser
+ */
+interface LdapOrganization {
+    dn: string;
+    ou?: string;
+    [key: string]: unknown;
+}
+interface LdapSubnode {
+    dn: string;
+    type: string;
+    [key: string]: unknown;
+}
+interface LdapListResponse {
+    entries: unknown[];
+    total?: number;
+}
+export declare class LdapApiClient {
+    private baseUrl;
+    private authToken?;
+    constructor(baseUrl: string, authToken?: string | undefined);
+    private fetch;
+    getTopOrganization(): Promise<LdapOrganization>;
+    getOrganization(dn: string): Promise<LdapOrganization>;
+    getOrganizationSubnodes(dn: string): Promise<LdapSubnode[]>;
+    searchOrganizationSubnodes(dn: string, query: string): Promise<LdapSubnode[]>;
+    getUsers(filter?: string): Promise<LdapListResponse>;
+    getGroups(filter?: string): Promise<LdapListResponse>;
+}
+export {};

package/dist/src/browser/ldap-tree-viewer/components/TreeNode.d.ts

@@ -0,0 +1,17 @@
+/**
+ * TreeNode component - renders individual tree nodes
+ */
+import type { TreeState } from '../types';
+import type { Store } from '../store/Store';
+export declare class TreeNodeComponent {
+    private dn;
+    private store;
+    private onToggle;
+    private onClick;
+    constructor(dn: string, store: Store<TreeState>, onToggle: (dn: string) => void, onClick: (dn: string) => void);
+    render(): HTMLElement;
+    private createContent;
+    private createSpinner;
+    private getClassNames;
+    private getIcon;
+}

package/dist/src/browser/ldap-tree-viewer/components/TreeRoot.d.ts

@@ -0,0 +1,14 @@
+/**
+ * TreeRoot component - renders the root container and tree
+ */
+import type { TreeState } from '../types';
+import type { Store } from '../store/Store';
+export declare class TreeRoot {
+    private store;
+    private onClick;
+    private onToggle;
+    constructor(store: Store<TreeState>, onClick: (dn: string) => void, onToggle: (dn: string) => void);
+    render(): HTMLElement;
+    private createError;
+    private createLoading;
+}

package/dist/src/browser/ldap-tree-viewer/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LDAP Tree Viewer - Browser library
+ * @author Xavier Guimard
+ */
+import './styles.css';
+export { LdapTreeViewer } from './LdapTreeViewer';
+export type { ViewerOptions, TreeNode, TreeState, NodeType, FilterType, } from './types';

package/dist/src/browser/ldap-tree-viewer/store/Store.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Mini Store implementation (Redux-like pattern without dependencies)
+ */
+export type Listener = () => void;
+export type Reducer<S> = (state: S, action: Action) => S;
+export interface Action {
+    type: string;
+    payload?: unknown;
+}
+export declare class Store<S> {
+    private state;
+    private reducer;
+    private listeners;
+    constructor(reducer: Reducer<S>, initialState: S);
+    getState(): S;
+    dispatch(action: Action): void;
+    subscribe(listener: Listener): () => void;
+}

package/dist/src/browser/ldap-tree-viewer/store/actions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Action types and action creators
+ */
+import type { TreeNode } from '../types';
+import type { Action } from './Store';
+export declare const Actions: {
+    readonly SET_ROOT: "SET_ROOT";
+    readonly ADD_NODE: "ADD_NODE";
+    readonly UPDATE_NODE: "UPDATE_NODE";
+    readonly TOGGLE_EXPANDED: "TOGGLE_EXPANDED";
+    readonly SET_LOADING: "SET_LOADING";
+    readonly SET_ERROR: "SET_ERROR";
+    readonly SELECT_NODE: "SELECT_NODE";
+    readonly SET_SEARCH: "SET_SEARCH";
+    readonly SET_FILTER: "SET_FILTER";
+};
+export declare const setRoot: (node: TreeNode) => Action;
+export declare const addNode: (node: TreeNode) => Action;
+export declare const updateNode: (node: TreeNode) => Action;
+export declare const toggleExpanded: (dn: string) => Action;
+export declare const setLoading: (payload: {
+    dn: string;
+    loading: boolean;
+}) => Action;
+export declare const setError: (error: string | null) => Action;
+export declare const selectNode: (dn: string | null) => Action;
+export declare const setSearch: (query: string) => Action;
+export declare const setFilter: (filter: "all" | "organizations" | "users" | "groups") => Action;

package/dist/src/browser/ldap-tree-viewer/store/reducers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reducers for tree state management
+ */
+import type { TreeState } from '../types';
+import type { Action } from './Store';
+export declare const initialState: TreeState;
+export declare function treeReducer(state: TreeState, action: Action): TreeState;

package/dist/src/browser/ldap-tree-viewer/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * TypeScript interfaces and types for LDAP Tree Viewer
+ */
+export interface TreeState {
+    nodes: Map<string, TreeNode>;
+    rootDn: string | null;
+    expandedNodes: Set<string>;
+    loadingNodes: Set<string>;
+    selectedNode: string | null;
+    error: string | null;
+    searchQuery: string;
+    filter: 'all' | 'organizations' | 'users' | 'groups';
+}
+export interface TreeNode {
+    dn: string;
+    displayName: string;
+    type: 'organization' | 'user' | 'group' | 'more';
+    parentDn: string | null;
+    childrenDns: string[];
+    hasLoadedChildren: boolean;
+    hasChildren: boolean;
+    attributes?: Record<string, unknown>;
+}
+export interface ViewerOptions {
+    containerId: string;
+    apiBaseUrl: string;
+    authToken?: string;
+    rootDn?: string;
+    theme?: 'light' | 'dark';
+    onNodeClick?: (node: TreeNode) => void;
+    onNodeExpand?: (node: TreeNode) => void;
+}
+export type NodeType = 'organization' | 'user' | 'group' | 'more';
+export type FilterType = 'all' | 'organizations' | 'users' | 'groups';

package/dist/src/browser/ldap-unit-editor/LdapUnitEditor.d.ts

@@ -0,0 +1,27 @@
+/**
+ * LDAP Unit Editor - Main component for editing organizational units
+ */
+import { UnitApiClient } from './api/UnitApiClient.js';
+import type { UnitEditorOptions, Config } from './types';
+export declare class LdapUnitEditor {
+    private container;
+    private options;
+    private api;
+    private unitTree;
+    private unitEditor;
+    private currentUnitDn;
+    private config;
+    constructor(options: UnitEditorOptions);
+    init(): Promise<void>;
+    private render;
+    private initializeComponents;
+    private onUnitSelected;
+    getCurrentUnitDn(): string | null;
+    refresh(): Promise<void>;
+    getApi(): UnitApiClient;
+    getConfig(): Config | null;
+    getCurrentOrgDn(): string | null;
+    getCurrentUserDn(): string | null;
+    createUser(data: Record<string, unknown>): Promise<void>;
+    deleteUser(dn: string): Promise<void>;
+}

package/dist/src/browser/ldap-unit-editor/api/UnitApiClient.d.ts

@@ -0,0 +1,24 @@
+/**
+ * API Client for LDAP Unit operations
+ */
+import type { Config, LdapUnit } from '../types';
+export declare class UnitApiClient {
+    private baseUrl;
+    constructor(baseUrl: string);
+    getConfig(): Promise<Config>;
+    getOrganizations(): Promise<{
+        dn: string;
+    }>;
+    getUnit(dn: string): Promise<LdapUnit>;
+    updateUnit(dn: string, data: Partial<LdapUnit>): Promise<void>;
+    createEntry(dn: string, data: Record<string, unknown>): Promise<void>;
+    deleteEntry(dn: string): Promise<void>;
+    getPointerOptions(branch: string): Promise<Array<{
+        dn: string;
+        label: string;
+    }>>;
+    moveUnit(dn: string, targetOrgDn: string): Promise<{
+        success: boolean;
+        newDn?: string;
+    }>;
+}

package/dist/src/browser/ldap-unit-editor/components/MoveUnitModal.d.ts

@@ -0,0 +1,28 @@
+/**
+ * LDAP Unit Editor - Move Unit Modal Component
+ * Modal dialog for selecting target organization when moving a unit
+ */
+import type { UnitApiClient } from '../api/UnitApiClient';
+export declare class MoveUnitModal {
+    private modal;
+    private api;
+    private currentOrgDn;
+    private selectedOrgDn;
+    private onMove;
+    private expandedNodes;
+    private rootDn;
+    constructor(api: UnitApiClient, 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-unit-editor/components/UnitPropertyEditor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Unit Property Editor Component - Edits properties of a selected organizational unit
+ */
+import type { UnitApiClient } from '../api/UnitApiClient';
+export declare class UnitPropertyEditor {
+    private container;
+    private api;
+    private unitDn;
+    private unit;
+    private schema;
+    private saveCallback;
+    private hasSubnodes;
+    constructor(container: HTMLElement, api: UnitApiClient, unitDn: string);
+    init(): Promise<void>;
+    private loadUnit;
+    private checkSubnodes;
+    private loadSchema;
+    onSave(callback: () => void): void;
+    private render;
+    private renderFields;
+    private renderField;
+    private getFieldLabel;
+    private attachEventListeners;
+    private handleSubmit;
+    private handleMove;
+    private handleDelete;
+    private escapeHtml;
+}

package/dist/src/browser/ldap-unit-editor/components/UnitTree.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Unit Tree Component - Shows organizations tree (same as UserTree)
+ */
+export declare class UnitTree {
+    private container;
+    private apiBaseUrl;
+    private onOrgSelect;
+    private expandedNodes;
+    private selectedDn;
+    private rootDn;
+    constructor(container: HTMLElement, apiBaseUrl: string, onOrgSelect: (orgDn: string) => void);
+    init(): Promise<void>;
+    private handleCreateUnit;
+    private renderTree;
+    private renderNode;
+    private attachEventListeners;
+    private escapeHtml;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * LDAP Unit Editor - Entry point
+ * @author Xavier Guimard
+ */
+export { LdapUnitEditor } from './LdapUnitEditor.js';
+export type { UnitEditorOptions, Config, LdapUnit } from './types.js';

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

@@ -0,0 +1,55 @@
+/**
+ * TypeScript types for LDAP Unit Editor
+ */
+export interface UnitEditorOptions {
+    containerId: string;
+    apiBaseUrl?: string;
+    onUnitSaved?: (unitDn: string) => void;
+    onError?: (error: Error) => void;
+}
+export interface Config {
+    ldapBase: string;
+    features?: {
+        flatResources?: ResourceConfig[];
+        ldapFlatGeneric?: {
+            flatResources?: ResourceConfig[];
+        };
+        ldapOrganizations?: {
+            schemaUrl?: string;
+            schema?: SchemaDefinition;
+        };
+    };
+    [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 LdapUnit {
+    dn: string;
+    ou: string;
+    description?: string;
+    [key: string]: unknown;
+}