@ductape/sdk 0.0.4-v6 → 0.0.4-v61

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

@@ -0,0 +1,702 @@
+"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