@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/products/validators/joi-validators/create.productDatabaseAction.validator.js

@@ -33,554 +33,162 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NOSQLDatabaseActionsSchema = exports.SQLDatabaseActionSchema = exports.DatabaseActionSchema = exports.validateDatabaseFilterTemplate = exports.validateDatabaseTemplate = void 0;
+exports.NOSQLDatabaseActionsSchema = exports.validateMongoFilterTemplate = exports.validateMongoTemplate = exports.mongoValidTypeMap = exports.SQLDatabaseActionSchema = exports.validateSQLWithPlaceholders = void 0;
 const Joi = __importStar(require("joi"));
 const inputs_types_1 = require("../../../types/inputs.types");
 const productsBuilder_types_1 = require("../../../types/productsBuilder.types");
+//import { MySQL } from 'dt-sql-parser';
 const placeholderPattern = /\{\{[^}]+\}\}/g;
-/**
- * Helper to check if a value has a valid value or contains placeholders
- */
-const hasValidValue = (value) => {
-    if (value === undefined || value === null)
-        return false;
-    if (typeof value === 'string') {
-        return value.length > 0;
-    }
-    if (typeof value === 'object') {
-        return Object.keys(value).length > 0 || JSON.stringify(value).match(placeholderPattern) !== null;
-    }
-    return true;
-};
-/**
- * Valid comparison operators
- */
-const validComparisonOperators = [
-    '=', '!=', '>', '>=', '<', '<=',
-    'like', 'not_like', 'in', 'not_in',
-    'between', 'not_between', 'is_null', 'is_not_null',
-    'contains', 'not_contains',
-];
-/**
- * Valid join types
- */
-const validJoinTypes = ['inner', 'left', 'right', 'full', 'cross'];
-/**
- * Valid sort orders
- */
-const validSortOrders = ['asc', 'desc'];
-/**
- * Validates where clause structure
- * Supports: object notation, IWhereCondition, IWhereGroup, or arrays
- */
-const validateWhereClause = (where, fieldName) => {
-    if (!where || typeof where !== 'object') {
-        return `${fieldName} must be a valid object.`;
-    }
-    // If it's a simple object notation (Record<string, any>), it's valid
-    const hasColumn = hasValidValue(where.column);
-    const hasOperator = hasValidValue(where.operator);
-    const hasConditions = Array.isArray(where.conditions);
-    // IWhereCondition structure
-    if (hasColumn) {
-        if (!hasOperator) {
-            return `${fieldName} with column must also have operator.`;
-        }
-        // Validate operator if it's not a placeholder
-        if (typeof where.operator === 'string' && !where.operator.match(placeholderPattern)) {
-            if (!validComparisonOperators.includes(where.operator.toLowerCase())) {
-                return `${fieldName} operator must be one of: ${validComparisonOperators.join(', ')}.`;
-            }
-        }
-    }
-    // IWhereGroup structure
-    if (hasConditions) {
-        const validLogicalOps = ['and', 'or', 'not'];
-        if (where.operator && !validLogicalOps.includes(where.operator.toLowerCase())) {
-            return `${fieldName} group operator must be one of: ${validLogicalOps.join(', ')}.`;
-        }
-    }
-    return null;
-};
-/**
- * Validates orderBy structure
- */
-const validateOrderBy = (orderBy) => {
-    if (!orderBy)
-        return null;
-    const validateSingle = (item) => {
-        if (!hasValidValue(item.column)) {
-            return 'orderBy must have column.';
-        }
-        if (item.order && typeof item.order === 'string' && !item.order.match(placeholderPattern)) {
-            if (!validSortOrders.includes(item.order.toLowerCase())) {
-                return `orderBy order must be one of: ${validSortOrders.join(', ')}.`;
-            }
-        }
-        return null;
-    };
-    if (Array.isArray(orderBy)) {
-        for (const item of orderBy) {
-            const error = validateSingle(item);
-            if (error)
-                return error;
-        }
-    }
-    else if (typeof orderBy === 'object') {
-        return validateSingle(orderBy);
-    }
-    return null;
-};
-/**
- * Validates join clause structure
- */
-const validateJoinClause = (join) => {
-    if (!join.type || !validJoinTypes.includes(join.type.toLowerCase())) {
-        return `Join type must be one of: ${validJoinTypes.join(', ')}.`;
-    }
-    if (!hasValidValue(join.table)) {
-        return 'Join must have table.';
-    }
-    if (!hasValidValue(join.leftColumn)) {
-        return 'Join must have leftColumn.';
-    }
-    if (!hasValidValue(join.rightColumn)) {
-        return 'Join must have rightColumn.';
-    }
-    return null;
-};
-/**
- * Validates QUERY action template (IQueryOptions)
- * Expected: table (required), select?, where?, orderBy?, limit?, offset?, joins?, include?, groupBy?, having?, distinct?
- */
-const validateQueryOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'QUERY action requires table.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    // Validate orderBy if present
-    if (options.orderBy) {
-        const orderByError = validateOrderBy(options.orderBy);
-        if (orderByError)
-            return orderByError;
-    }
-    // Validate joins if present
-    if (options.joins && Array.isArray(options.joins)) {
-        for (const join of options.joins) {
-            const joinError = validateJoinClause(join);
-            if (joinError)
-                return joinError;
+function extractSqlKeywords(sql) {
+    const keywords = [];
+    const lowered = sql.toLowerCase();
+    const regex = /\b(insert|select|update|delete)\b/g;
+    let match;
+    while ((match = regex.exec(lowered)) !== null) {
+        keywords.push(match[1]);
+    }
+    return keywords;
+}
+const validateSQLWithPlaceholders = (value, helpers) => {
+    var _a;
+    if (typeof value !== 'string') {
+        return helpers.error('any.invalid', { message: 'Template must be a string.' });
+    }
+    try {
+        const actionType = (_a = helpers.state.ancestors[0]) === null || _a === void 0 ? void 0 : _a.type;
+        const validTypeMap = {
+            read: 'select',
+            create: 'insert',
+            update: 'update',
+            delete: 'delete',
+            aggregate: 'select',
+        };
+        const expectedKeyword = validTypeMap[actionType];
+        const sqlKeywords = extractSqlKeywords(value);
+        if (!sqlKeywords.length) {
+            return helpers.error('any.invalid', {
+                message: 'Template must contain a valid SQL operation like INSERT, SELECT, UPDATE, or DELETE.',
+            });
         }
-    }
-    // Validate groupBy if present
-    if (options.groupBy && !Array.isArray(options.groupBy)) {
-        return 'groupBy must be an array of column names.';
-    }
-    return null;
-};
-/**
- * Validates INSERT action template (IInsertOptions)
- * Expected: table (required), data (required), returning?, ignoreErrors?, onConflict?
- */
-const validateInsertOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'INSERT action requires table.';
-    }
-    if (!hasValidValue(options.data)) {
-        return 'INSERT action requires data (record or array of records to insert).';
-    }
-    // Validate onConflict if present
-    if (options.onConflict) {
-        if (!Array.isArray(options.onConflict.columns) || options.onConflict.columns.length === 0) {
-            return 'onConflict must have columns array.';
+        // Check that at least one SQL operation matches the expected type
+        const matches = sqlKeywords.some(kw => kw === expectedKeyword);
+        if (!matches) {
+            return helpers.error('any.invalid', {
+                message: `Template SQL must match the action type: ${actionType}`,
+            });
         }
-        if (options.onConflict.action && !['ignore', 'update'].includes(options.onConflict.action)) {
-            return 'onConflict action must be one of: ignore, update.';
+        // Check for placeholders
+        const placeholders = value.match(placeholderPattern);
+        if (!placeholders || placeholders.length === 0) {
+            return helpers.error('any.invalid', {
+                message: 'Template must include placeholders in the format {{valueName}}.',
+            });
         }
     }
-    return null;
-};
-/**
- * Validates UPDATE action template (IUpdateOptions)
- * Expected: table (required), data (required), where (required), returning?, limit?
- */
-const validateUpdateOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'UPDATE action requires table.';
-    }
-    if (!hasValidValue(options.data)) {
-        return 'UPDATE action requires data (fields to update).';
-    }
-    if (!hasValidValue(options.where)) {
-        return 'UPDATE action requires where clause to identify records.';
-    }
-    // Validate where clause
-    if (typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates DELETE action template (IDeleteOptions)
- * Expected: table (required), where (required), returning?, limit?
- */
-const validateDeleteOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'DELETE action requires table.';
-    }
-    if (!hasValidValue(options.where)) {
-        return 'DELETE action requires where clause to identify records.';
-    }
-    // Validate where clause
-    if (typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates UPSERT action template (IUpsertOptions)
- * Expected: table (required), data (required), uniqueColumns (required), updateColumns?, returning?
- */
-const validateUpsertOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'UPSERT action requires table.';
-    }
-    if (!hasValidValue(options.data)) {
-        return 'UPSERT action requires data (record or array of records).';
-    }
-    if (!hasValidValue(options.uniqueColumns) || !Array.isArray(options.uniqueColumns) || options.uniqueColumns.length === 0) {
-        return 'UPSERT action requires uniqueColumns array to define conflict columns.';
-    }
-    return null;
-};
-/**
- * Validates COUNT action template
- * Expected: table (required), where?, column?
- */
-const validateCountOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'COUNT action requires table.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates SUM action template
- * Expected: table (required), column (required), where?
- */
-const validateSumOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'SUM action requires table.';
-    }
-    if (!hasValidValue(options.column)) {
-        return 'SUM action requires column to sum.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates AVERAGE action template
- * Expected: table (required), column (required), where?
- */
-const validateAverageOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'AVERAGE action requires table.';
-    }
-    if (!hasValidValue(options.column)) {
-        return 'AVERAGE action requires column to average.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates MINIMUM action template
- * Expected: table (required), column (required), where?
- */
-const validateMinimumOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'MINIMUM action requires table.';
-    }
-    if (!hasValidValue(options.column)) {
-        return 'MINIMUM action requires column to find minimum.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates MAXIMUM action template
- * Expected: table (required), column (required), where?
- */
-const validateMaximumOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'MAXIMUM action requires table.';
-    }
-    if (!hasValidValue(options.column)) {
-        return 'MAXIMUM action requires column to find maximum.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    return null;
-};
-/**
- * Validates GROUP_BY action template
- * Expected: table (required), groupBy (required), select?, where?, having?, orderBy?, limit?
- */
-const validateGroupByOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'GROUP_BY action requires table.';
-    }
-    if (!hasValidValue(options.groupBy) || !Array.isArray(options.groupBy) || options.groupBy.length === 0) {
-        return 'GROUP_BY action requires groupBy array of column names.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    // Validate having clause if present
-    if (options.having && typeof options.having === 'object' && !JSON.stringify(options.having).match(placeholderPattern)) {
-        const havingError = validateWhereClause(options.having, 'having');
-        if (havingError)
-            return havingError;
-    }
-    // Validate orderBy if present
-    if (options.orderBy) {
-        const orderByError = validateOrderBy(options.orderBy);
-        if (orderByError)
-            return orderByError;
-    }
-    return null;
-};
-/**
- * Validates AGGREGATE action template (complex aggregation query)
- * Expected: table (required), select?, where?, groupBy?, having?, orderBy?, limit?
- */
-const validateAggregateOptions = (options) => {
-    if (!hasValidValue(options.table)) {
-        return 'AGGREGATE action requires table.';
-    }
-    // Validate where clause if present
-    if (options.where && typeof options.where === 'object' && !JSON.stringify(options.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(options.where, 'where');
-        if (whereError)
-            return whereError;
-    }
-    // Validate groupBy if present
-    if (options.groupBy && !Array.isArray(options.groupBy)) {
-        return 'groupBy must be an array of column names.';
-    }
-    // Validate having clause if present
-    if (options.having && typeof options.having === 'object' && !JSON.stringify(options.having).match(placeholderPattern)) {
-        const havingError = validateWhereClause(options.having, 'having');
-        if (havingError)
-            return havingError;
-    }
-    // Validate orderBy if present
-    if (options.orderBy) {
-        const orderByError = validateOrderBy(options.orderBy);
-        if (orderByError)
-            return orderByError;
-    }
-    return null;
-};
-/**
- * Validates RAW_SQL action template
- * Expected: query (required), params?
- */
-const validateRawSqlOptions = (options) => {
-    if (!hasValidValue(options.query)) {
-        return 'RAW_SQL action requires query string.';
+    catch (err) {
+        return helpers.error('any.invalid', {
+            message: 'Template must contain valid SQL syntax, match the type, and include valid placeholders.',
+        });
     }
-    return null;
+    return value;
 };
-/**
- * Validates database action template based on action type
- * Uses the new structured query interface (IQueryOptions, IInsertOptions, IUpdateOptions, IDeleteOptions)
- */
-const validateDatabaseTemplate = (value, helpers) => {
+exports.validateSQLWithPlaceholders = validateSQLWithPlaceholders;
+// Define schema
+exports.SQLDatabaseActionSchema = Joi.object({
+    name: Joi.string().required(),
+    tag: Joi.string()
+        .pattern(inputs_types_1.tagPattern)
+        .messages(inputs_types_1.tagMessage)
+        .required(),
+    description: Joi.string().optional(),
+    tableName: Joi.string()
+        .pattern(inputs_types_1.tagPattern)
+        .messages(inputs_types_1.tableMessage)
+        .required(),
+    type: Joi.string().valid(...Object.values(productsBuilder_types_1.DatabaseActionTypes)).required(),
+    template: Joi.custom(exports.validateSQLWithPlaceholders).required().messages({
+        'any.invalid': 'Template must contain valid SQL syntax, match the type, and include valid placeholders.',
+    }),
+});
+exports.mongoValidTypeMap = {
+    read: ['find', 'findOne'],
+    count: ['countDocuments', 'estimatedDocumentCount'],
+    create: ['insertOne', 'insertMany'],
+    update: ['updateOne', 'updateMany'],
+    delete: ['deleteOne', 'deleteMany'],
+    aggregate: ['aggregate'],
+};
+const validateMongoTemplate = (value, helpers) => {
     var _a;
     if (typeof value !== 'object' || value === null) {
         return helpers.error('any.invalid', {
-            message: 'Template must be a valid query options object.',
+            message: 'Template must be a valid MongoDB query object.',
+        });
+    }
+    const actionType = (_a = helpers.state.ancestors[0]) === null || _a === void 0 ? void 0 : _a.type; // Get the action type from the parent object
+    const validOperations = exports.mongoValidTypeMap[actionType] || [];
+    // Validate the template operation
+    if (!validOperations.some((op) => op in value)) {
+        return helpers.error('any.invalid', {
+            message: `Template must include a valid MongoDB operation for the action type: ${actionType}. Valid operations: ${validOperations.join(', ')}.`,
         });
     }
-    const actionType = (_a = helpers.state.ancestors[0]) === null || _a === void 0 ? void 0 : _a.type;
     // Check for placeholders in the template
     const templateStr = JSON.stringify(value);
     const placeholders = templateStr.match(placeholderPattern);
-    if (!placeholders || placeholders.length === 0) {
+    if (!placeholders) {
         return helpers.error('any.invalid', {
             message: 'Template must include placeholders in the format {{valueName}}.',
         });
     }
-    let validationError = null;
-    // Type-specific validations based on the expected interface for each action type
-    switch (actionType) {
-        // Basic CRUD operations
-        case productsBuilder_types_1.DatabaseActionTypes.QUERY:
-        case productsBuilder_types_1.DatabaseActionTypes.READ: // Legacy alias
-            validationError = validateQueryOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.INSERT:
-        case productsBuilder_types_1.DatabaseActionTypes.CREATE: // Legacy alias
-            validationError = validateInsertOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.UPDATE:
-            validationError = validateUpdateOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.DELETE:
-            validationError = validateDeleteOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.UPSERT:
-            validationError = validateUpsertOptions(value);
-            break;
-        // Aggregation operations
-        case productsBuilder_types_1.DatabaseActionTypes.COUNT:
-            validationError = validateCountOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.SUM:
-            validationError = validateSumOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.AVERAGE:
-            validationError = validateAverageOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.MINIMUM:
-            validationError = validateMinimumOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.MAXIMUM:
-            validationError = validateMaximumOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.GROUP_BY:
-            validationError = validateGroupByOptions(value);
-            break;
-        case productsBuilder_types_1.DatabaseActionTypes.AGGREGATE:
-            validationError = validateAggregateOptions(value);
-            break;
-        // Raw query
-        case productsBuilder_types_1.DatabaseActionTypes.RAW_SQL:
-            validationError = validateRawSqlOptions(value);
-            break;
-        default:
-            validationError = `Unknown action type: ${actionType}`;
-            break;
-    }
-    if (validationError) {
-        return helpers.error('any.invalid', {
-            message: validationError,
-        });
-    }
     return value;
 };
-exports.validateDatabaseTemplate = validateDatabaseTemplate;
-/**
- * Validates the filter template for update/delete operations
- * FilterTemplate should be a where clause structure
- */
-const validateDatabaseFilterTemplate = (value, helpers) => {
-    var _a;
+exports.validateMongoTemplate = validateMongoTemplate;
+const validateMongoFilterTemplate = (value, helpers) => {
     if (typeof value !== 'object' || value === null) {
         return helpers.error('any.invalid', {
-            message: 'FilterTemplate must be a valid filter object.',
+            message: 'FilterTemplate must be a valid MongoDB filter object.',
         });
     }
-    const actionType = (_a = helpers.state.ancestors[0]) === null || _a === void 0 ? void 0 : _a.type;
-    // Filter templates are typically used for update/delete operations
-    if (![productsBuilder_types_1.DatabaseActionTypes.UPDATE, productsBuilder_types_1.DatabaseActionTypes.DELETE].includes(actionType)) {
+    // Ensure the top-level key is `where` and it contains a sub-object
+    const keys = Object.keys(value);
+    if (keys.length !== 1 || keys[0] !== 'where' || typeof value.where !== 'object' || value.where === null) {
         return helpers.error('any.invalid', {
-            message: `FilterTemplate is not applicable for action type "${actionType}".`,
+            message: 'FilterTemplate must contain a single key "where" with a sub-object as its value.',
         });
     }
-    // Check for placeholders in the filter template
-    const filterStr = JSON.stringify(value);
-    const placeholders = filterStr.match(placeholderPattern);
-    if (!placeholders || placeholders.length === 0) {
+    // Check for placeholders in the `where` sub-object
+    const whereStr = JSON.stringify(value.where);
+    const placeholderPattern = /{{\s*[\w.]+\s*}}/g; // Match placeholders in the format {{valueName}}
+    const placeholders = whereStr.match(placeholderPattern);
+    if (!placeholders) {
         return helpers.error('any.invalid', {
-            message: 'FilterTemplate must include placeholders in the format {{valueName}}.',
+            message: 'FilterTemplate "where" sub-object must include placeholders in the format {{valueName}}.',
         });
     }
-    // Validate where clause structure if it has a where key
-    if (value.where && typeof value.where === 'object' && !JSON.stringify(value.where).match(placeholderPattern)) {
-        const whereError = validateWhereClause(value.where, 'where');
-        if (whereError) {
-            return helpers.error('any.invalid', { message: whereError });
-        }
-    }
     return value;
 };
-exports.validateDatabaseFilterTemplate = validateDatabaseFilterTemplate;
-/**
- * Schema for creating database actions using the structured query interface
- */
-exports.DatabaseActionSchema = Joi.object({
-    name: Joi.string().required().messages({
-        'any.required': 'name is required',
-    }),
+exports.validateMongoFilterTemplate = validateMongoFilterTemplate;
+// MongoDB Schema
+exports.NOSQLDatabaseActionsSchema = Joi.object({
+    name: Joi.string().required(),
+    description: Joi.string().required(),
     tag: Joi.string()
         .pattern(inputs_types_1.tagPattern)
         .messages(inputs_types_1.tagMessage)
         .required(),
-    description: Joi.string().optional(),
     tableName: Joi.string()
         .pattern(inputs_types_1.tagPattern)
         .messages(inputs_types_1.tableMessage)
         .required(),
     type: Joi.string()
         .valid(...Object.values(productsBuilder_types_1.DatabaseActionTypes))
-        .required()
-        .messages({
-        'any.only': `type must be one of: ${Object.values(productsBuilder_types_1.DatabaseActionTypes).join(', ')}`,
-    }),
+        .required(),
     template: Joi.object()
-        .custom(exports.validateDatabaseTemplate, 'Database template validation')
-        .required()
-        .messages({
-        'any.invalid': 'Template must be a valid query options object with placeholders.',
-    }),
+        .custom(exports.validateMongoTemplate, 'MongoDB template validation')
+        .required(),
     filterTemplate: Joi.object()
-        .custom(exports.validateDatabaseFilterTemplate, 'Database filter template validation')
-        .optional()
-        .messages({
-        'any.invalid': 'FilterTemplate must be a valid filter object with placeholders.',
-    }),
+        .custom(exports.validateMongoFilterTemplate, 'MongoDB filter template validation')
+        .optional(), // Filter template is optional, depending on the operation
 });
-// Legacy schemas for backwards compatibility - these are deprecated
-// @deprecated Use DatabaseActionSchema instead
-exports.SQLDatabaseActionSchema = exports.DatabaseActionSchema;
-// @deprecated Use DatabaseActionSchema instead
-exports.NOSQLDatabaseActionsSchema = exports.DatabaseActionSchema;
-exports.default = exports.DatabaseActionSchema;
 //# sourceMappingURL=create.productDatabaseAction.validator.js.map