@ductape/sdk 0.1.6 → 0.1.8

package/dist/database/presave/presave-processor.js

@@ -1,702 +0,0 @@
-"use strict";
-/**
- * Pre-Save Processor
- *
- * Processes data before database write operations by applying
- * encryption, hashing, validation, transformation, and other operations.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PreSave = exports.PreSaveProcessor = void 0;
-const crypto = __importStar(require("crypto"));
-const presave_interface_1 = require("../types/presave.interface");
-/**
- * Pre-save processor for applying transformations before database writes
- */
-class PreSaveProcessor {
-    constructor(config = {}) {
-        this.config = Object.assign({ defaultHashAlgorithm: 'sha256', defaultSaltRounds: 10, throwOnValidationError: true }, config);
-    }
-    /**
-     * Process data through pre-save operations
-     */
-    async process(data, operations) {
-        const isArray = Array.isArray(data);
-        const records = isArray ? data : [data];
-        const appliedOperations = [];
-        const validationErrors = [];
-        // Sort operations by type to ensure proper order
-        // (defaults first, then validations, then transformations, then encryption/hash)
-        const sortedOps = this.sortOperations(operations);
-        const processedRecords = await Promise.all(records.map(async (record) => {
-            const processed = Object.assign({}, record);
-            for (const op of sortedOps) {
-                const result = await this.applyOperation(processed, op, validationErrors);
-                appliedOperations.push(result.applied);
-                if (result.data) {
-                    Object.assign(processed, result.data);
-                }
-            }
-            return processed;
-        }));
-        // Check for validation errors
-        if (validationErrors.length > 0 && this.config.throwOnValidationError) {
-            const errorMessages = validationErrors.map(e => `${e.field}: ${e.message}`).join(', ');
-            throw new Error(`Validation failed: ${errorMessages}`);
-        }
-        return {
-            data: isArray ? processedRecords : processedRecords[0],
-            appliedOperations,
-            validationErrors: validationErrors.length > 0 ? validationErrors : undefined,
-            success: validationErrors.length === 0,
-        };
-    }
-    /**
-     * Sort operations for proper execution order
-     */
-    sortOperations(operations) {
-        const order = {
-            [presave_interface_1.PreSaveOperationType.DEFAULT]: 1,
-            [presave_interface_1.PreSaveOperationType.COMPUTE]: 2,
-            [presave_interface_1.PreSaveOperationType.VALIDATE]: 3,
-            [presave_interface_1.PreSaveOperationType.TRIM]: 4,
-            [presave_interface_1.PreSaveOperationType.LOWERCASE]: 5,
-            [presave_interface_1.PreSaveOperationType.UPPERCASE]: 5,
-            [presave_interface_1.PreSaveOperationType.NORMALIZE_EMAIL]: 5,
-            [presave_interface_1.PreSaveOperationType.NORMALIZE_PHONE]: 5,
-            [presave_interface_1.PreSaveOperationType.SANITIZE]: 6,
-            [presave_interface_1.PreSaveOperationType.TRUNCATE]: 7,
-            [presave_interface_1.PreSaveOperationType.SLUG]: 8,
-            [presave_interface_1.PreSaveOperationType.ROUND]: 9,
-            [presave_interface_1.PreSaveOperationType.CLAMP]: 9,
-            [presave_interface_1.PreSaveOperationType.PARSE_JSON]: 10,
-            [presave_interface_1.PreSaveOperationType.STRINGIFY_JSON]: 10,
-            [presave_interface_1.PreSaveOperationType.UUID]: 11,
-            [presave_interface_1.PreSaveOperationType.TIMESTAMP]: 11,
-            [presave_interface_1.PreSaveOperationType.TRANSFORM]: 12,
-            [presave_interface_1.PreSaveOperationType.MASK]: 13,
-            [presave_interface_1.PreSaveOperationType.HASH]: 14,
-            [presave_interface_1.PreSaveOperationType.ENCRYPT]: 15,
-        };
-        return [...operations].sort((a, b) => (order[a.type] || 99) - (order[b.type] || 99));
-    }
-    /**
-     * Apply a single operation to a record
-     */
-    async applyOperation(record, op, validationErrors) {
-        const appliedRecord = {
-            field: op.field,
-            operation: op.type,
-            applied: false,
-        };
-        // Check condition
-        if (op.condition && !op.condition(record)) {
-            appliedRecord.skippedReason = 'Condition not met';
-            return { data: null, applied: appliedRecord };
-        }
-        const value = record[op.field];
-        // Check skipIfNull
-        if (op.skipIfNull && (value === null || value === undefined)) {
-            appliedRecord.skippedReason = 'Value is null/undefined';
-            return { data: null, applied: appliedRecord };
-        }
-        // Check skipIfEmpty
-        if (op.skipIfEmpty && value === '') {
-            appliedRecord.skippedReason = 'Value is empty';
-            return { data: null, applied: appliedRecord };
-        }
-        try {
-            const result = await this.executeOperation(record, op, validationErrors);
-            appliedRecord.applied = true;
-            return { data: result, applied: appliedRecord };
-        }
-        catch (error) {
-            appliedRecord.skippedReason = `Error: ${error.message}`;
-            throw error;
-        }
-    }
-    /**
-     * Execute a specific operation
-     */
-    async executeOperation(record, op, validationErrors) {
-        switch (op.type) {
-            case presave_interface_1.PreSaveOperationType.ENCRYPT:
-                return this.encrypt(record, op);
-            case presave_interface_1.PreSaveOperationType.HASH:
-                return this.hash(record, op);
-            case presave_interface_1.PreSaveOperationType.MASK:
-                return this.mask(record, op);
-            case presave_interface_1.PreSaveOperationType.VALIDATE:
-                return this.validate(record, op, validationErrors);
-            case presave_interface_1.PreSaveOperationType.TRANSFORM:
-                return this.transform(record, op);
-            case presave_interface_1.PreSaveOperationType.SLUG:
-                return this.generateSlug(record, op);
-            case presave_interface_1.PreSaveOperationType.TRUNCATE:
-                return this.truncate(record, op);
-            case presave_interface_1.PreSaveOperationType.ROUND:
-                return this.round(record, op);
-            case presave_interface_1.PreSaveOperationType.CLAMP:
-                return this.clamp(record, op);
-            case presave_interface_1.PreSaveOperationType.DEFAULT:
-                return this.applyDefault(record, op);
-            case presave_interface_1.PreSaveOperationType.COMPUTE:
-                return this.compute(record, op);
-            case presave_interface_1.PreSaveOperationType.TRIM:
-                return { [op.field]: typeof record[op.field] === 'string' ? record[op.field].trim() : record[op.field] };
-            case presave_interface_1.PreSaveOperationType.LOWERCASE:
-                return { [op.field]: typeof record[op.field] === 'string' ? record[op.field].toLowerCase() : record[op.field] };
-            case presave_interface_1.PreSaveOperationType.UPPERCASE:
-                return { [op.field]: typeof record[op.field] === 'string' ? record[op.field].toUpperCase() : record[op.field] };
-            case presave_interface_1.PreSaveOperationType.SANITIZE:
-                return { [op.field]: this.sanitizeHtml(record[op.field]) };
-            case presave_interface_1.PreSaveOperationType.UUID:
-                return { [op.field]: this.generateUUID() };
-            case presave_interface_1.PreSaveOperationType.TIMESTAMP:
-                return { [op.field]: new Date() };
-            case presave_interface_1.PreSaveOperationType.NORMALIZE_PHONE:
-                return { [op.field]: this.normalizePhone(record[op.field]) };
-            case presave_interface_1.PreSaveOperationType.NORMALIZE_EMAIL:
-                return { [op.field]: this.normalizeEmail(record[op.field]) };
-            case presave_interface_1.PreSaveOperationType.PARSE_JSON:
-                return { [op.field]: typeof record[op.field] === 'string' ? JSON.parse(record[op.field]) : record[op.field] };
-            case presave_interface_1.PreSaveOperationType.STRINGIFY_JSON:
-                return { [op.field]: typeof record[op.field] === 'object' ? JSON.stringify(record[op.field]) : record[op.field] };
-            default:
-                return {};
-        }
-    }
-    // ==================== OPERATION IMPLEMENTATIONS ====================
-    /**
-     * Encrypt a field value
-     */
-    encrypt(record, op) {
-        const value = record[op.field];
-        if (value === null || value === undefined)
-            return {};
-        const key = op.key || this.config.encryptionKey;
-        if (!key) {
-            throw new Error(`Encryption key required for field '${op.field}'. Set via config or operation options.`);
-        }
-        const algorithm = op.algorithm || 'aes-256-gcm';
-        const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
-        // Derive a 32-byte key from the provided key
-        const derivedKey = crypto.createHash('sha256').update(key).digest();
-        if (algorithm === 'aes-256-gcm' || algorithm === 'aes-128-gcm') {
-            const iv = crypto.randomBytes(16);
-            const keyLength = algorithm === 'aes-256-gcm' ? 32 : 16;
-            const cipher = crypto.createCipheriv(algorithm, derivedKey.slice(0, keyLength), iv);
-            let encrypted = cipher.update(stringValue, 'utf8', 'hex');
-            encrypted += cipher.final('hex');
-            const authTag = cipher.getAuthTag().toString('hex');
-            // Combine IV + authTag + encrypted data
-            const encryptedValue = `${iv.toString('hex')}:${authTag}:${encrypted}`;
-            const result = { [op.field]: encryptedValue };
-            if (op.storeIV) {
-                const ivField = op.ivField || `${op.field}_iv`;
-                result[ivField] = iv.toString('hex');
-            }
-            return result;
-        }
-        else {
-            // CBC mode
-            const iv = crypto.randomBytes(16);
-            const cipher = crypto.createCipheriv('aes-256-cbc', derivedKey, iv);
-            let encrypted = cipher.update(stringValue, 'utf8', 'hex');
-            encrypted += cipher.final('hex');
-            const encryptedValue = `${iv.toString('hex')}:${encrypted}`;
-            const result = { [op.field]: encryptedValue };
-            if (op.storeIV) {
-                const ivField = op.ivField || `${op.field}_iv`;
-                result[ivField] = iv.toString('hex');
-            }
-            return result;
-        }
-    }
-    /**
-     * Hash a field value (one-way)
-     */
-    async hash(record, op) {
-        const value = record[op.field];
-        if (value === null || value === undefined)
-            return {};
-        const stringValue = typeof value === 'string' ? value : String(value);
-        const algorithm = op.algorithm || this.config.defaultHashAlgorithm || 'sha256';
-        switch (algorithm) {
-            case 'bcrypt': {
-                // Bcrypt requires the bcrypt package - we'll use a simple implementation
-                // In production, you'd want to use the actual bcrypt package
-                const saltRounds = op.saltRounds || this.config.defaultSaltRounds || 10;
-                const salt = crypto.randomBytes(16).toString('hex');
-                const hash = crypto.pbkdf2Sync(stringValue, salt, Math.pow(2, saltRounds), 64, 'sha512').toString('hex');
-                return { [op.field]: `$pbkdf2$${saltRounds}$${salt}$${hash}` };
-            }
-            case 'argon2': {
-                // Argon2 would require the argon2 package
-                // Fallback to PBKDF2 with higher iterations
-                const salt = crypto.randomBytes(16).toString('hex');
-                const hash = crypto.pbkdf2Sync(stringValue, salt, 100000, 64, 'sha512').toString('hex');
-                return { [op.field]: `$argon2-compat$${salt}$${hash}` };
-            }
-            case 'sha256': {
-                const salt = op.salt || '';
-                const hash = crypto.createHash('sha256').update(salt + stringValue).digest('hex');
-                return { [op.field]: hash };
-            }
-            case 'sha512': {
-                const salt = op.salt || '';
-                const hash = crypto.createHash('sha512').update(salt + stringValue).digest('hex');
-                return { [op.field]: hash };
-            }
-            case 'md5': {
-                const salt = op.salt || '';
-                const hash = crypto.createHash('md5').update(salt + stringValue).digest('hex');
-                return { [op.field]: hash };
-            }
-            default:
-                throw new Error(`Unknown hash algorithm: ${algorithm}`);
-        }
-    }
-    /**
-     * Mask sensitive data
-     */
-    mask(record, op) {
-        const value = record[op.field];
-        if (value === null || value === undefined)
-            return {};
-        const stringValue = String(value);
-        const result = {};
-        // Store original if requested
-        if (op.storeOriginalIn) {
-            result[op.storeOriginalIn] = value;
-        }
-        const maskChar = op.maskChar || '*';
-        let masked;
-        switch (op.pattern) {
-            case 'credit-card':
-                // Show last 4 digits: **** **** **** 1234
-                masked = stringValue.replace(/\d(?=\d{4})/g, maskChar);
-                break;
-            case 'ssn':
-                // Show last 4 digits: ***-**-1234
-                masked = stringValue.replace(/\d(?=.{4})/g, maskChar);
-                break;
-            case 'phone':
-                // Show last 4 digits: (***) ***-1234
-                const digits = stringValue.replace(/\D/g, '');
-                if (digits.length >= 4) {
-                    const lastFour = digits.slice(-4);
-                    masked = maskChar.repeat(digits.length - 4) + lastFour;
-                }
-                else {
-                    masked = maskChar.repeat(stringValue.length);
-                }
-                break;
-            case 'email':
-                // Show first char and domain: j***@example.com
-                const atIndex = stringValue.indexOf('@');
-                if (atIndex > 1) {
-                    masked = stringValue[0] + maskChar.repeat(atIndex - 1) + stringValue.slice(atIndex);
-                }
-                else {
-                    masked = stringValue;
-                }
-                break;
-            case 'custom':
-            default:
-                const showFirst = op.showFirst || 0;
-                const showLast = op.showLast || 0;
-                const maskLength = stringValue.length - showFirst - showLast;
-                if (maskLength > 0) {
-                    masked = stringValue.slice(0, showFirst) +
-                        maskChar.repeat(maskLength) +
-                        stringValue.slice(-showLast || undefined);
-                }
-                else {
-                    masked = stringValue;
-                }
-                break;
-        }
-        result[op.field] = masked;
-        return result;
-    }
-    /**
-     * Validate field value
-     */
-    validate(record, op, validationErrors) {
-        const value = record[op.field];
-        for (const rule of op.rules) {
-            const isValid = this.checkValidationRule(value, rule, record);
-            if (!isValid) {
-                const error = {
-                    field: op.field,
-                    message: rule.message || op.errorMessage || this.getDefaultValidationMessage(rule),
-                    rule: rule.type,
-                    value,
-                };
-                if (op.throwOnFail !== false && this.config.throwOnValidationError) {
-                    throw new Error(`Validation failed for '${op.field}': ${error.message}`);
-                }
-                validationErrors.push(error);
-                if (op.resultField) {
-                    return { [op.resultField]: false };
-                }
-            }
-        }
-        if (op.resultField) {
-            return { [op.resultField]: true };
-        }
-        return {};
-    }
-    /**
-     * Check a single validation rule
-     */
-    checkValidationRule(value, rule, record) {
-        switch (rule.type) {
-            case 'required':
-                return value !== null && value !== undefined && value !== '';
-            case 'email':
-                return typeof value === 'string' && /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
-            case 'url':
-                try {
-                    new URL(value);
-                    return true;
-                }
-                catch (_a) {
-                    return false;
-                }
-            case 'minLength':
-                return typeof value === 'string' && value.length >= rule.value;
-            case 'maxLength':
-                return typeof value === 'string' && value.length <= rule.value;
-            case 'min':
-                return typeof value === 'number' && value >= rule.value;
-            case 'max':
-                return typeof value === 'number' && value <= rule.value;
-            case 'pattern':
-                return typeof value === 'string' && new RegExp(rule.value).test(value);
-            case 'enum':
-                return rule.value.includes(value);
-            case 'type':
-                return typeof value === rule.value;
-            case 'integer':
-                return Number.isInteger(value);
-            case 'positive':
-                return typeof value === 'number' && value > 0;
-            case 'negative':
-                return typeof value === 'number' && value < 0;
-            case 'custom':
-                return rule.validator ? rule.validator(value, record) : true;
-            default:
-                return true;
-        }
-    }
-    /**
-     * Get default validation error message
-     */
-    getDefaultValidationMessage(rule) {
-        switch (rule.type) {
-            case 'required': return 'This field is required';
-            case 'email': return 'Invalid email address';
-            case 'url': return 'Invalid URL';
-            case 'minLength': return `Minimum length is ${rule.value}`;
-            case 'maxLength': return `Maximum length is ${rule.value}`;
-            case 'min': return `Minimum value is ${rule.value}`;
-            case 'max': return `Maximum value is ${rule.value}`;
-            case 'pattern': return 'Value does not match required pattern';
-            case 'enum': return `Value must be one of: ${rule.value.join(', ')}`;
-            case 'type': return `Value must be of type ${rule.value}`;
-            case 'integer': return 'Value must be an integer';
-            case 'positive': return 'Value must be positive';
-            case 'negative': return 'Value must be negative';
-            default: return 'Validation failed';
-        }
-    }
-    /**
-     * Apply custom transformation
-     */
-    transform(record, op) {
-        const value = record[op.field];
-        const transformed = op.transformer(value, record);
-        return { [op.field]: transformed };
-    }
-    /**
-     * Generate slug from source field
-     */
-    generateSlug(record, op) {
-        const sourceValue = record[op.sourceField];
-        if (!sourceValue)
-            return {};
-        let slug = String(sourceValue);
-        // Convert to lowercase
-        if (op.lowercase !== false) {
-            slug = slug.toLowerCase();
-        }
-        // Remove special characters
-        if (op.removeSpecialChars !== false) {
-            slug = slug
-                .normalize('NFD')
-                .replace(/[\u0300-\u036f]/g, '') // Remove diacritics
-                .replace(/[^a-z0-9\s-]/gi, ''); // Remove special chars
-        }
-        // Replace spaces with separator
-        const separator = op.separator || '-';
-        slug = slug.trim().replace(/\s+/g, separator);
-        // Remove consecutive separators
-        slug = slug.replace(new RegExp(`${separator}+`, 'g'), separator);
-        // Trim separators from ends
-        slug = slug.replace(new RegExp(`^${separator}|${separator}$`, 'g'), '');
-        // Apply max length
-        if (op.maxLength && slug.length > op.maxLength) {
-            slug = slug.slice(0, op.maxLength).replace(new RegExp(`${separator}$`), '');
-        }
-        return { [op.field]: slug };
-    }
-    /**
-     * Truncate string to max length
-     */
-    truncate(record, op) {
-        var _a;
-        const value = record[op.field];
-        if (typeof value !== 'string' || value.length <= op.maxLength) {
-            return {};
-        }
-        const suffix = (_a = op.suffix) !== null && _a !== void 0 ? _a : '...';
-        const maxContentLength = op.maxLength - suffix.length;
-        let truncated;
-        if (op.wordBoundary) {
-            // Truncate at word boundary
-            truncated = value.slice(0, maxContentLength);
-            const lastSpace = truncated.lastIndexOf(' ');
-            if (lastSpace > 0) {
-                truncated = truncated.slice(0, lastSpace);
-            }
-        }
-        else {
-            truncated = value.slice(0, maxContentLength);
-        }
-        return { [op.field]: truncated + suffix };
-    }
-    /**
-     * Round number to decimals
-     */
-    round(record, op) {
-        var _a;
-        const value = record[op.field];
-        if (typeof value !== 'number')
-            return {};
-        const decimals = (_a = op.decimals) !== null && _a !== void 0 ? _a : 2;
-        const multiplier = Math.pow(10, decimals);
-        let rounded;
-        switch (op.mode) {
-            case 'floor':
-                rounded = Math.floor(value * multiplier) / multiplier;
-                break;
-            case 'ceil':
-                rounded = Math.ceil(value * multiplier) / multiplier;
-                break;
-            default:
-                rounded = Math.round(value * multiplier) / multiplier;
-        }
-        return { [op.field]: rounded };
-    }
-    /**
-     * Clamp number to range
-     */
-    clamp(record, op) {
-        const value = record[op.field];
-        if (typeof value !== 'number')
-            return {};
-        let clamped = value;
-        if (op.min !== undefined)
-            clamped = Math.max(clamped, op.min);
-        if (op.max !== undefined)
-            clamped = Math.min(clamped, op.max);
-        return { [op.field]: clamped };
-    }
-    /**
-     * Apply default value if null/undefined
-     */
-    applyDefault(record, op) {
-        const value = record[op.field];
-        if (value !== null && value !== undefined)
-            return {};
-        const defaultValue = op.generator ? op.generator(record) : op.value;
-        return { [op.field]: defaultValue };
-    }
-    /**
-     * Compute derived field
-     */
-    compute(record, op) {
-        const computed = op.compute(record);
-        return { [op.field]: computed };
-    }
-    // ==================== UTILITY METHODS ====================
-    /**
-     * Sanitize HTML/script tags
-     */
-    sanitizeHtml(value) {
-        if (typeof value !== 'string')
-            return value;
-        if (this.config.sanitizer) {
-            return this.config.sanitizer(value);
-        }
-        // Basic sanitization - remove script tags and common XSS patterns
-        return value
-            .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
-            .replace(/javascript:/gi, '')
-            .replace(/on\w+\s*=/gi, '')
-            .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
-            .replace(/<object\b[^<]*(?:(?!<\/object>)<[^<]*)*<\/object>/gi, '')
-            .replace(/<embed\b[^>]*>/gi, '')
-            .replace(/<[^>]+>/g, ''); // Remove all remaining HTML tags
-    }
-    /**
-     * Generate UUID v4
-     */
-    generateUUID() {
-        return crypto.randomUUID();
-    }
-    /**
-     * Normalize phone number
-     */
-    normalizePhone(value) {
-        if (typeof value !== 'string')
-            return value;
-        // Remove all non-digit characters except leading +
-        const hasPlus = value.startsWith('+');
-        const digits = value.replace(/\D/g, '');
-        return hasPlus ? `+${digits}` : digits;
-    }
-    /**
-     * Normalize email
-     */
-    normalizeEmail(value) {
-        if (typeof value !== 'string')
-            return value;
-        return value.trim().toLowerCase();
-    }
-    // ==================== STATIC HELPERS ====================
-    /**
-     * Create an encryption operation
-     */
-    static encrypt(field, options) {
-        return Object.assign({ field, type: presave_interface_1.PreSaveOperationType.ENCRYPT }, options);
-    }
-    /**
-     * Create a hash operation
-     */
-    static hash(field, options) {
-        return Object.assign({ field, type: presave_interface_1.PreSaveOperationType.HASH }, options);
-    }
-    /**
-     * Create a mask operation
-     */
-    static mask(field, pattern, options) {
-        return Object.assign({ field, type: presave_interface_1.PreSaveOperationType.MASK, pattern }, options);
-    }
-    /**
-     * Create a validate operation
-     */
-    static validate(field, rules, options) {
-        return Object.assign({ field, type: presave_interface_1.PreSaveOperationType.VALIDATE, rules }, options);
-    }
-    /**
-     * Create a transform operation
-     */
-    static transform(field, transformer) {
-        return { field, type: presave_interface_1.PreSaveOperationType.TRANSFORM, transformer };
-    }
-    /**
-     * Create a slug operation
-     */
-    static slug(field, sourceField, options) {
-        return Object.assign({ field, type: presave_interface_1.PreSaveOperationType.SLUG, sourceField }, options);
-    }
-    /**
-     * Create a compute operation
-     */
-    static compute(field, compute, dependsOn) {
-        return { field, type: presave_interface_1.PreSaveOperationType.COMPUTE, compute, dependsOn };
-    }
-    /**
-     * Create a default operation
-     */
-    static default(field, value) {
-        return { field, type: presave_interface_1.PreSaveOperationType.DEFAULT, value };
-    }
-    /**
-     * Create simple operation helpers
-     */
-    static trim(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.TRIM };
-    }
-    static lowercase(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.LOWERCASE };
-    }
-    static uppercase(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.UPPERCASE };
-    }
-    static sanitize(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.SANITIZE };
-    }
-    static uuid(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.UUID };
-    }
-    static timestamp(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.TIMESTAMP };
-    }
-    static normalizeEmail(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.NORMALIZE_EMAIL };
-    }
-    static normalizePhone(field) {
-        return { field, type: presave_interface_1.PreSaveOperationType.NORMALIZE_PHONE };
-    }
-    static truncate(field, maxLength, options) {
-        return Object.assign({ field, type: presave_interface_1.PreSaveOperationType.TRUNCATE, maxLength }, options);
-    }
-    static round(field, decimals, mode) {
-        return { field, type: presave_interface_1.PreSaveOperationType.ROUND, decimals, mode };
-    }
-    static clamp(field, min, max) {
-        return { field, type: presave_interface_1.PreSaveOperationType.CLAMP, min, max };
-    }
-}
-exports.PreSaveProcessor = PreSaveProcessor;
-/**
- * Convenience export for operation builder
- */
-exports.PreSave = PreSaveProcessor;
-//# sourceMappingURL=presave-processor.js.map