@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -33,162 +33,554 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NOSQLDatabaseActionsSchema = exports.validateMongoFilterTemplate = exports.validateMongoTemplate = exports.mongoValidTypeMap = exports.SQLDatabaseActionSchema = exports.validateSQLWithPlaceholders = void 0;
+exports.NOSQLDatabaseActionsSchema = exports.SQLDatabaseActionSchema = exports.DatabaseActionSchema = exports.validateDatabaseFilterTemplate = exports.validateDatabaseTemplate = 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;
-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.',
-            });
+/**
+ * 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.`;
         }
-        // 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}`,
-            });
+        // 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(', ')}.`;
+            }
         }
-        // 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}}.',
-            });
+    }
+    // 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(', ')}.`;
         }
     }
-    catch (err) {
-        return helpers.error('any.invalid', {
-            message: 'Template must contain valid SQL syntax, match the type, and include valid placeholders.',
-        });
+    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;
+        }
     }
-    return value;
+    else if (typeof orderBy === 'object') {
+        return validateSingle(orderBy);
+    }
+    return null;
 };
-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) => {
+/**
+ * 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;
+        }
+    }
+    // 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.';
+        }
+        if (options.onConflict.action && !['ignore', 'update'].includes(options.onConflict.action)) {
+            return 'onConflict action must be one of: ignore, update.';
+        }
+    }
+    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.';
+    }
+    return null;
+};
+/**
+ * Validates database action template based on action type
+ * Uses the new structured query interface (IQueryOptions, IInsertOptions, IUpdateOptions, IDeleteOptions)
+ */
+const validateDatabaseTemplate = (value, helpers) => {
     var _a;
     if (typeof value !== 'object' || value === null) {
         return helpers.error('any.invalid', {
-            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(', ')}.`,
+            message: 'Template must be a valid query options object.',
         });
     }
+    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) {
+    if (!placeholders || placeholders.length === 0) {
         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.validateMongoTemplate = validateMongoTemplate;
-const validateMongoFilterTemplate = (value, helpers) => {
+exports.validateDatabaseTemplate = validateDatabaseTemplate;
+/**
+ * Validates the filter template for update/delete operations
+ * FilterTemplate should be a where clause structure
+ */
+const validateDatabaseFilterTemplate = (value, helpers) => {
+    var _a;
     if (typeof value !== 'object' || value === null) {
         return helpers.error('any.invalid', {
-            message: 'FilterTemplate must be a valid MongoDB filter object.',
+            message: 'FilterTemplate must be a valid filter object.',
         });
     }
-    // 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) {
+    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)) {
         return helpers.error('any.invalid', {
-            message: 'FilterTemplate must contain a single key "where" with a sub-object as its value.',
+            message: `FilterTemplate is not applicable for action type "${actionType}".`,
         });
     }
-    // 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) {
+    // Check for placeholders in the filter template
+    const filterStr = JSON.stringify(value);
+    const placeholders = filterStr.match(placeholderPattern);
+    if (!placeholders || placeholders.length === 0) {
         return helpers.error('any.invalid', {
-            message: 'FilterTemplate "where" sub-object must include placeholders in the format {{valueName}}.',
+            message: 'FilterTemplate 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.validateMongoFilterTemplate = validateMongoFilterTemplate;
-// MongoDB Schema
-exports.NOSQLDatabaseActionsSchema = Joi.object({
-    name: Joi.string().required(),
-    description: Joi.string().required(),
+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',
+    }),
     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(),
+        .required()
+        .messages({
+        'any.only': `type must be one of: ${Object.values(productsBuilder_types_1.DatabaseActionTypes).join(', ')}`,
+    }),
     template: Joi.object()
-        .custom(exports.validateMongoTemplate, 'MongoDB template validation')
-        .required(),
+        .custom(exports.validateDatabaseTemplate, 'Database template validation')
+        .required()
+        .messages({
+        'any.invalid': 'Template must be a valid query options object with placeholders.',
+    }),
     filterTemplate: Joi.object()
-        .custom(exports.validateMongoFilterTemplate, 'MongoDB filter template validation')
-        .optional(), // Filter template is optional, depending on the operation
+        .custom(exports.validateDatabaseFilterTemplate, 'Database filter template validation')
+        .optional()
+        .messages({
+        'any.invalid': 'FilterTemplate must be a valid filter object with placeholders.',
+    }),
 });
+// 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