bindra 2.0.0

package/dist/core/DataSource.js

@@ -0,0 +1,903 @@
+// bindra/core/DataSource.ts
+import { EventEmitter } from './EventEmitter';
+import { MiddlewareManager } from './MiddlewareManager';
+import { reactive, createSignal } from './Observable';
+import { NetworkError, PermissionError, ConfigurationError, ValidationError } from './errors';
+import { Validator } from './validation';
+/**
+ * DataSource - Type-safe reactive data management with CRUD operations
+ *
+ * @template T - The type of records managed by this DataSource
+ *
+ * @example
+ * ```typescript
+ * interface User {
+ *   id: number;
+ *   name: string;
+ *   email: string;
+ * }
+ *
+ * const ds = new DataSource<User>({
+ *   data: [{ id: 1, name: 'Alice', email: 'alice@example.com' }]
+ * });
+ * ```
+ */
+export class DataSource extends EventEmitter {
+    constructor({ url = null, data = null, retry, fields, cache, pageSize, realtime, security } = {}) {
+        super();
+        this.url = url;
+        this.data = null;
+        this.fields = [];
+        this.fieldConfigs = fields || []; // NEW: Store field configs
+        this.validator = fields ? new Validator(fields) : null; // NEW: Create validator
+        this.permissions = {};
+        this.middleware = new MiddlewareManager();
+        this.retryConfig = {
+            maxRetries: retry?.maxRetries ?? 3,
+            retryDelay: retry?.retryDelay ?? 1000,
+            backoffMultiplier: retry?.backoffMultiplier ?? 2
+        };
+        // Cache configuration
+        this.cache = new Map();
+        this.cacheConfig = cache || { enabled: false };
+        // Real-time configuration
+        this.realtimeConfig = realtime || { enabled: false };
+        // Security configuration
+        this.securityConfig = security || {};
+        // Navigation signals
+        this.currentIndex = createSignal(0);
+        this.currentRecord = createSignal(null);
+        // Pagination signal
+        this.pagination = createSignal({
+            pageSize: pageSize || 10,
+            currentPage: 1
+        });
+        // Determine data mode
+        this.isLocal = Array.isArray(data);
+        if (this.isLocal) {
+            this._initLocal(data);
+        }
+        else if (url) {
+            this._initRemote(url);
+        }
+        else {
+            throw new ConfigurationError('Either "url" or "data" must be provided', { url, data });
+        }
+        // Initialize WebSocket if configured
+        if (this.realtimeConfig.enabled) {
+            this.connectWebSocket();
+        }
+    }
+    async _initRemote(url) {
+        const configUrl = `${url}/config`;
+        try {
+            const res = await this._fetchWithRetry(configUrl, { method: 'GET' });
+            if (!res.ok) {
+                throw new NetworkError(`Failed to load config from ${configUrl}`, res.status, await res.text());
+            }
+            const config = await res.json();
+            this.fields = config.fields || [];
+            this.permissions = config.permissions || {};
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    _initLocal(data) {
+        if (!Array.isArray(data) || !data.every(x => typeof x === 'object')) {
+            throw new ConfigurationError('Local data must be an array of objects', { data });
+        }
+        // Make reactive data store
+        this.data = reactive(structuredClone(data), () => {
+            this.emit('dataChanged', this.data);
+        });
+        this.fields = Object.keys(this.data[0] || {}).map(k => ({
+            name: k,
+            type: typeof this.data[0][k]
+        }));
+        this.permissions = { allowInsert: true, allowUpdate: true, allowDelete: true };
+        if (this.data.length > 0) {
+            this.currentRecord.set(this.data[0]);
+        }
+    }
+    // ------------------------------
+    // CRUD OPERATIONS
+    // ------------------------------
+    /**
+     * Create a new record
+     *
+     * @param record - The record to create (can be partial)
+     * @returns Promise resolving to the created record
+     *
+     * @example
+     * ```typescript
+     * const newUser = await ds.create({
+     *   name: 'Alice',
+     *   email: 'alice@example.com'
+     * });
+     * ```
+     */
+    async create(record) {
+        try {
+            // Check permissions
+            if (this.permissions.allowInsert === false) {
+                throw new PermissionError('Insert operation not permitted', 'create');
+            }
+            // Apply defaults
+            if (this.validator) {
+                record = this.validator.applyDefaults(record);
+            }
+            // Sanitize record for security
+            record = this.sanitizeRecord(record);
+            // Validate record
+            if (this.validator) {
+                const errors = await this.validator.validateRecord(record);
+                if (errors) {
+                    throw new ValidationError('Validation failed', errors);
+                }
+            }
+            await this.middleware.runBefore('create', { record, ds: this });
+            let created;
+            if (this.isLocal) {
+                this.data.push(record);
+                created = record;
+            }
+            else {
+                const res = await this._fetchWithRetry(this.url, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(record)
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Create failed: ${res.statusText}`, res.status, await res.text());
+                }
+                created = await res.json();
+            }
+            this.emit('created', created);
+            this.emit('dataChanged', this.data);
+            await this.middleware.runAfter('create', { record: created, ds: this });
+            // Update cache
+            if (created.id !== undefined) {
+                this.setCache(created.id, created);
+            }
+            return created;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Update an existing record
+     *
+     * @param key - The key/id of the record to update
+     * @param changes - Partial changes to apply
+     * @returns Promise resolving to the updated record
+     */
+    async update(key, changes) {
+        try {
+            // Check permissions
+            if (this.permissions.allowUpdate === false) {
+                throw new PermissionError('Update operation not permitted', 'update');
+            }
+            // Validate changes
+            if (this.validator) {
+                const errors = await this.validator.validateRecord(changes);
+                if (errors) {
+                    throw new ValidationError('Validation failed', errors);
+                }
+            }
+            // Sanitize changes for security
+            changes = this.sanitizeRecord(changes);
+            await this.middleware.runBefore('update', { key, changes, ds: this });
+            let updated;
+            if (this.isLocal) {
+                const idx = this.data.findIndex(r => r.id === key);
+                if (idx < 0)
+                    throw new Error('Record not found.');
+                Object.assign(this.data[idx], changes);
+                updated = this.data[idx];
+            }
+            else {
+                const res = await this._fetchWithRetry(`${this.url}/${key}`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(changes)
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Update failed: ${res.statusText}`, res.status, await res.text());
+                }
+                updated = await res.json();
+            }
+            this.emit('updated', updated);
+            this.emit('dataChanged', this.data);
+            await this.middleware.runAfter('update', { record: updated, ds: this });
+            return updated;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete a record
+     *
+     * @param key - The key/id of the record to delete
+     * @returns Promise resolving to the deleted record
+     */
+    async delete(key) {
+        try {
+            // Check permissions
+            if (this.permissions.allowDelete === false) {
+                throw new PermissionError('Delete operation not permitted', 'delete');
+            }
+            await this.middleware.runBefore('delete', { key, ds: this });
+            let deleted;
+            if (this.isLocal) {
+                const idx = this.data.findIndex(r => r.id === key);
+                if (idx < 0) {
+                    throw new NetworkError(`Record with key ${key} not found`, 404);
+                }
+                deleted = this.data.splice(idx, 1)[0];
+            }
+            else {
+                const res = await this._fetchWithRetry(`${this.url}/${key}`, {
+                    method: 'DELETE'
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Delete failed: ${res.statusText}`, res.status, await res.text());
+                }
+                deleted = await res.json();
+            }
+            this.emit('deleted', deleted);
+            this.emit('dataChanged', this.data);
+            await this.middleware.runAfter('delete', { record: deleted, ds: this });
+            return deleted;
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    // ------------------------------
+    // BATCH OPERATIONS
+    // ------------------------------
+    /**
+     * Create multiple records in a single operation
+     *
+     * @param records - Array of partial records to create
+     * @returns Promise resolving to array of created records
+     */
+    async createBatch(records) {
+        try {
+            if (this.permissions.allowInsert === false) {
+                throw new PermissionError('Insert operation not permitted', 'createBatch');
+            }
+            // Validate all records
+            if (this.validator) {
+                for (const record of records) {
+                    const errors = await this.validator.validateRecord(record);
+                    if (errors) {
+                        throw new ValidationError('Validation failed in batch create', errors);
+                    }
+                }
+            }
+            if (this.isLocal) {
+                const created = records.map(r => ({ ...r }));
+                this.data.push(...created);
+                this.emit('dataChanged', this.data);
+                created.forEach(rec => this.emit('created', rec));
+                return created;
+            }
+            else {
+                const res = await this._fetchWithRetry(`${this.url}/batch`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(records)
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Batch create failed: ${res.statusText}`, res.status);
+                }
+                const created = await res.json();
+                this.emit('dataChanged', null);
+                created.forEach(rec => this.emit('created', rec));
+                return created;
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Update multiple records in a single operation
+     *
+     * @param updates - Array of { key, changes } objects
+     * @returns Promise resolving to array of updated records
+     */
+    async updateBatch(updates) {
+        try {
+            if (this.permissions.allowUpdate === false) {
+                throw new PermissionError('Update operation not permitted', 'updateBatch');
+            }
+            // Validate all changes
+            if (this.validator) {
+                for (const { changes } of updates) {
+                    const errors = await this.validator.validateRecord(changes);
+                    if (errors) {
+                        throw new ValidationError('Validation failed in batch update', errors);
+                    }
+                }
+            }
+            if (this.isLocal) {
+                const updated = [];
+                for (const { key, changes } of updates) {
+                    const idx = this.data.findIndex(r => r.id === key);
+                    if (idx >= 0) {
+                        Object.assign(this.data[idx], changes);
+                        updated.push(this.data[idx]);
+                        this.emit('updated', this.data[idx]);
+                    }
+                }
+                this.emit('dataChanged', this.data);
+                return updated;
+            }
+            else {
+                const res = await this._fetchWithRetry(`${this.url}/batch`, {
+                    method: 'PUT',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(updates)
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Batch update failed: ${res.statusText}`, res.status);
+                }
+                const updated = await res.json();
+                this.emit('dataChanged', null);
+                updated.forEach(rec => this.emit('updated', rec));
+                return updated;
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Delete multiple records in a single operation
+     *
+     * @param keys - Array of keys/ids to delete
+     * @returns Promise resolving to array of deleted records
+     */
+    async deleteBatch(keys) {
+        try {
+            if (this.permissions.allowDelete === false) {
+                throw new PermissionError('Delete operation not permitted', 'deleteBatch');
+            }
+            if (this.isLocal) {
+                const deleted = [];
+                for (const key of keys) {
+                    const idx = this.data.findIndex(r => r.id === key);
+                    if (idx >= 0) {
+                        const [record] = this.data.splice(idx, 1);
+                        deleted.push(record);
+                        this.emit('deleted', record);
+                    }
+                }
+                this.emit('dataChanged', this.data);
+                return deleted;
+            }
+            else {
+                const res = await this._fetchWithRetry(`${this.url}/batch`, {
+                    method: 'DELETE',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ keys })
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Batch delete failed: ${res.statusText}`, res.status);
+                }
+                const deleted = await res.json();
+                this.emit('dataChanged', null);
+                deleted.forEach(rec => this.emit('deleted', rec));
+                return deleted;
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Optimistic update - immediately update UI, rollback on error
+     *
+     * @param key - The key/id of the record to update
+     * @param changes - Partial changes to apply
+     * @returns Promise resolving to the updated record
+     */
+    async updateOptimistic(key, changes) {
+        let original = null;
+        let idx = -1;
+        // Store original state
+        if (this.isLocal) {
+            idx = this.data.findIndex(r => r.id === key);
+            if (idx >= 0) {
+                original = { ...this.data[idx] };
+                // Apply changes immediately
+                Object.assign(this.data[idx], changes);
+                this.emit('updated', this.data[idx]);
+                this.emit('dataChanged', this.data);
+            }
+        }
+        try {
+            // Make actual update request
+            const updated = await this.update(key, changes);
+            // Update cache
+            this.setCache(key, updated);
+            return updated;
+        }
+        catch (error) {
+            // Rollback on error
+            if (original && this.isLocal && idx >= 0) {
+                this.data[idx] = original;
+                this.emit('updated', original);
+                this.emit('dataChanged', this.data);
+            }
+            throw error;
+        }
+    }
+    // ------------------------------
+    // QUERY API
+    // ------------------------------
+    /**
+     * Query records with filtering, sorting, and limiting
+     *
+     * @param options - Query options
+     * @returns Promise resolving to array of matching records
+     */
+    async query({ filter = null, sort = null, limit = null } = {}) {
+        try {
+            if (this.isLocal) {
+                let result = [...this.data];
+                if (typeof filter === 'function') {
+                    result = result.filter(filter);
+                }
+                if (typeof sort === 'string') {
+                    result.sort((a, b) => (a[sort] > b[sort] ? 1 : -1));
+                }
+                if (typeof sort === 'function') {
+                    result.sort(sort);
+                }
+                if (typeof limit === 'number') {
+                    result = result.slice(0, limit);
+                }
+                return result;
+            }
+            else {
+                const params = new URLSearchParams();
+                if (filter)
+                    params.set('filter', JSON.stringify(filter));
+                if (sort)
+                    params.set('sort', typeof sort === 'string' ? sort : JSON.stringify(sort));
+                if (limit)
+                    params.set('limit', limit.toString());
+                const res = await this._fetchWithRetry(`${this.url}?${params.toString()}`, {
+                    method: 'GET'
+                });
+                if (!res.ok) {
+                    throw new NetworkError(`Query failed: ${res.statusText}`, res.status, await res.text());
+                }
+                return await res.json();
+            }
+        }
+        catch (error) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+    /**
+     * Find a record by its key (local mode only)
+     *
+     * @param key - The key/id to search for
+     * @returns The found record or undefined
+     */
+    findByKey(key) {
+        if (!this.isLocal)
+            throw new Error('findByKey only supported in local mode.');
+        return this.data.find(r => r.id === key);
+    }
+    // ------------------------------
+    // INTERNAL HELPERS
+    // ------------------------------
+    /**
+     * Fetch with automatic retry and exponential backoff
+     *
+     * @param url - The URL to fetch
+     * @param options - Fetch options
+     * @returns Promise resolving to Response
+     */
+    async _fetchWithRetry(url, options) {
+        const { maxRetries, retryDelay, backoffMultiplier } = this.retryConfig;
+        let lastError;
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                // Merge security headers with provided headers
+                const securityHeaders = this.getSecurityHeaders();
+                const headers = {
+                    ...securityHeaders,
+                    ...(options.headers || {})
+                };
+                return await fetch(url, { ...options, headers });
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on last attempt
+                if (attempt === maxRetries) {
+                    break;
+                }
+                // Calculate delay with exponential backoff
+                const delay = retryDelay * Math.pow(backoffMultiplier, attempt);
+                // Emit retry event
+                this.emit('retrying', {
+                    attempt: attempt + 1,
+                    maxRetries,
+                    delay,
+                    error: lastError
+                });
+                // Wait before retrying
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+        }
+        // All retries exhausted
+        throw new NetworkError(`Network request failed after ${maxRetries} retries: ${lastError?.message || 'Unknown error'}`, undefined, { originalError: lastError, url, options });
+    }
+    // ------------------------------
+    // NAVIGATION
+    // ------------------------------
+    next() {
+        const idx = this.currentIndex.get();
+        if (idx < this.data.length - 1) {
+            const newIndex = idx + 1;
+            this.currentIndex.set(newIndex);
+            this.currentRecord.set(this.data[newIndex]);
+            this.emit('navigated', this.currentRecord.get());
+        }
+    }
+    prev() {
+        const idx = this.currentIndex.get();
+        if (idx > 0) {
+            const newIndex = idx - 1;
+            this.currentIndex.set(newIndex);
+            this.currentRecord.set(this.data[newIndex]);
+            this.emit('navigated', this.currentRecord.get());
+        }
+    }
+    goto(index) {
+        if (index < 0 || index >= this.data.length)
+            return;
+        this.currentIndex.set(index);
+        this.currentRecord.set(this.data[index]);
+        this.emit('navigated', this.currentRecord.get());
+    }
+    // ------------------------------
+    // CACHE MANAGEMENT
+    // ------------------------------
+    getCacheKey(key) {
+        return `record_${key}`;
+    }
+    /**
+     * Get a record from cache (internal use)
+     * @internal
+     */
+    getFromCache(key) {
+        if (!this.cacheConfig.enabled)
+            return null;
+        const cacheKey = this.getCacheKey(key);
+        const cached = this.cache.get(cacheKey);
+        if (!cached)
+            return null;
+        // Check TTL
+        if (this.cacheConfig.ttl) {
+            const age = Date.now() - cached.timestamp;
+            if (age > this.cacheConfig.ttl) {
+                this.cache.delete(cacheKey);
+                return null;
+            }
+        }
+        return cached.data;
+    }
+    setCache(key, data) {
+        if (!this.cacheConfig.enabled)
+            return;
+        const cacheKey = this.getCacheKey(key);
+        this.cache.set(cacheKey, { data, timestamp: Date.now() });
+        // Evict oldest if max size reached
+        if (this.cacheConfig.maxSize && this.cache.size > this.cacheConfig.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey !== undefined) {
+                this.cache.delete(firstKey);
+            }
+        }
+    }
+    /**
+     * Clear all cached records
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Invalidate a specific cached record
+     */
+    invalidateCache(key) {
+        const cacheKey = this.getCacheKey(key);
+        this.cache.delete(cacheKey);
+    }
+    // ------------------------------
+    // PAGINATION METHODS
+    // ------------------------------
+    /**
+     * Load a specific page of data
+     *
+     * @param page - Page number (1-indexed)
+     * @returns Array of records for the requested page
+     */
+    async loadPage(page) {
+        const paginationState = this.pagination.get();
+        if (this.isLocal) {
+            // Local pagination
+            const start = (page - 1) * paginationState.pageSize;
+            const end = start + paginationState.pageSize;
+            const pageData = this.data.slice(start, end);
+            this.pagination.set({
+                ...paginationState,
+                currentPage: page,
+                totalRecords: this.data.length,
+                totalPages: Math.ceil(this.data.length / paginationState.pageSize)
+            });
+            return pageData;
+        }
+        else {
+            // Remote pagination
+            const params = new URLSearchParams({
+                page: page.toString(),
+                pageSize: paginationState.pageSize.toString()
+            });
+            const res = await this._fetchWithRetry(`${this.url}?${params}`, {
+                method: 'GET'
+            });
+            if (!res.ok) {
+                throw new NetworkError(`Failed to load page: ${res.statusText}`, res.status);
+            }
+            const data = await res.json();
+            // Expect: { data: T[], total: number }
+            this.pagination.set({
+                ...paginationState,
+                currentPage: page,
+                totalRecords: data.total,
+                totalPages: Math.ceil(data.total / paginationState.pageSize)
+            });
+            return data.data;
+        }
+    }
+    /**
+     * Load the next page
+     */
+    async nextPage() {
+        const { currentPage, totalPages } = this.pagination.get();
+        if (totalPages && currentPage >= totalPages) {
+            return [];
+        }
+        return this.loadPage(currentPage + 1);
+    }
+    /**
+     * Load the previous page
+     */
+    async prevPage() {
+        const { currentPage } = this.pagination.get();
+        if (currentPage <= 1) {
+            return [];
+        }
+        return this.loadPage(currentPage - 1);
+    }
+    /**
+     * Set page size
+     */
+    setPageSize(size) {
+        const current = this.pagination.get();
+        this.pagination.set({
+            ...current,
+            pageSize: size,
+            currentPage: 1 // Reset to first page
+        });
+    }
+    // ------------------------------
+    // REAL-TIME WEBSOCKET SUPPORT
+    // ------------------------------
+    /**
+     * Connect to WebSocket for real-time updates
+     */
+    connectWebSocket() {
+        if (!this.realtimeConfig.enabled || !this.realtimeConfig.url) {
+            return;
+        }
+        try {
+            this.ws = new WebSocket(this.realtimeConfig.url);
+            this.ws.onopen = () => {
+                this.emit('realtime:connected');
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const message = JSON.parse(event.data);
+                    this.handleRealtimeUpdate(message);
+                }
+                catch (error) {
+                    this.emit('error', new Error('Failed to parse WebSocket message'));
+                }
+            };
+            this.ws.onclose = () => {
+                this.emit('realtime:disconnected');
+                if (this.realtimeConfig.reconnect) {
+                    setTimeout(() => this.connectWebSocket(), this.realtimeConfig.reconnectInterval || 5000);
+                }
+            };
+            this.ws.onerror = () => {
+                this.emit('error', new Error('WebSocket error'));
+            };
+        }
+        catch (error) {
+            this.emit('error', error);
+        }
+    }
+    /**
+     * Handle incoming WebSocket messages
+     */
+    handleRealtimeUpdate(message) {
+        const { type, data } = message;
+        switch (type) {
+            case 'created':
+                if (this.isLocal && data) {
+                    this.data.push(data);
+                }
+                this.emit('created', data);
+                this.emit('dataChanged', this.data);
+                break;
+            case 'updated':
+                if (this.isLocal && data) {
+                    const idx = this.data.findIndex(r => r.id === data.id);
+                    if (idx >= 0) {
+                        Object.assign(this.data[idx], data);
+                        this.emit('updated', data);
+                        this.emit('dataChanged', this.data);
+                    }
+                }
+                else {
+                    this.emit('updated', data);
+                    this.emit('dataChanged', null);
+                }
+                break;
+            case 'deleted':
+                if (this.isLocal && data) {
+                    const idx = this.data.findIndex(r => r.id === data.id);
+                    if (idx >= 0) {
+                        this.data.splice(idx, 1);
+                        this.emit('deleted', data);
+                        this.emit('dataChanged', this.data);
+                    }
+                }
+                else {
+                    this.emit('deleted', data);
+                    this.emit('dataChanged', null);
+                }
+                break;
+            default:
+                this.emit('realtime:message', message);
+        }
+    }
+    /**
+     * Disconnect WebSocket
+     */
+    disconnectWebSocket() {
+        if (this.ws) {
+            this.ws.close();
+            this.ws = undefined;
+        }
+    }
+    /**
+     * Send a message through WebSocket
+     */
+    sendWebSocketMessage(message) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+        else {
+            throw new Error('WebSocket is not connected');
+        }
+    }
+    // ------------------------------
+    // SECURITY HELPERS
+    // ------------------------------
+    /**
+     * Sanitize string to prevent XSS attacks
+     */
+    sanitize(value) {
+        return value
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;')
+            .replace(/'/g, '&#x27;')
+            .replace(/\//g, '&#x2F;');
+    }
+    /**
+     * Sanitize a record's fields that are marked for sanitization
+     */
+    sanitizeRecord(record) {
+        if (!this.securityConfig.sanitizeFields || this.securityConfig.sanitizeFields.length === 0) {
+            return record;
+        }
+        const sanitized = { ...record };
+        for (const field of this.securityConfig.sanitizeFields) {
+            const value = sanitized[field];
+            if (typeof value === 'string') {
+                sanitized[field] = this.sanitize(value);
+            }
+        }
+        return sanitized;
+    }
+    /**
+     * Get headers with CSRF token if configured
+     */
+    getSecurityHeaders() {
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        if (this.securityConfig.csrfToken && this.securityConfig.csrfHeader) {
+            headers[this.securityConfig.csrfHeader] = this.securityConfig.csrfToken;
+        }
+        return headers;
+    }
+    // ------------------------------
+    // VALIDATION HELPERS
+    // ------------------------------
+    /**
+     * Validate a single field
+     *
+     * @param fieldName - Name of the field to validate
+     * @param value - Value to validate
+     * @param record - Optional full record for context
+     * @returns Error message if invalid, null if valid
+     */
+    async validateField(fieldName, value, record) {
+        if (!this.validator) {
+            return null;
+        }
+        return this.validator.validateField(fieldName, value, record);
+    }
+    /**
+     * Validate a complete record
+     *
+     * @param record - Record to validate
+     * @returns Object with field errors, or null if valid
+     */
+    async validateRecord(record) {
+        if (!this.validator) {
+            return null;
+        }
+        return this.validator.validateRecord(record);
+    }
+    /**
+     * Get field configuration by name
+     *
+     * @param name - Field name
+     * @returns Field configuration or undefined
+     */
+    getFieldConfig(name) {
+        return this.validator?.getField(name);
+    }
+    /**
+     * Check if validation is enabled
+     */
+    hasValidation() {
+        return this.validator !== null;
+    }
+}
+//# sourceMappingURL=DataSource.js.map