@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,696 @@
+"use strict";
+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.GraphActionSchema = exports.validateGraphFilterTemplate = exports.validateGraphTemplate = void 0;
+const Joi = __importStar(require("joi"));
+const inputs_types_1 = require("../../../types/inputs.types");
+const productsBuilder_types_1 = require("../../../types/productsBuilder.types");
+const placeholderPattern = /\{\{[^}]+\}\}/g;
+/**
+ * Helper to check if a value contains placeholders or has a valid value
+ */
+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;
+};
+/**
+ * Validates node reference structure (used in fromNode, toNode, startNode, endNode)
+ */
+const validateNodeReference = (ref, fieldName) => {
+    if (!ref || typeof ref !== 'object') {
+        return `${fieldName} must be a valid object.`;
+    }
+    // A node reference should have at least one of: id, labels, properties, or where
+    const hasId = hasValidValue(ref.id);
+    const hasLabels = hasValidValue(ref.labels);
+    const hasProperties = hasValidValue(ref.properties);
+    const hasWhere = hasValidValue(ref.where);
+    if (!hasId && !hasLabels && !hasProperties && !hasWhere) {
+        return `${fieldName} must have at least one of: id, labels, properties, or where.`;
+    }
+    return null;
+};
+/**
+ * Validates where clause structure
+ */
+const validateWhereClause = (where, fieldName) => {
+    if (!where || typeof where !== 'object') {
+        return `${fieldName} must be a valid object.`;
+    }
+    // Where clause should have property, operator, and value (or and/or for compound)
+    const hasProperty = hasValidValue(where.property);
+    const hasOperator = hasValidValue(where.operator);
+    const hasValue = where.value !== undefined;
+    const hasAnd = Array.isArray(where.and) && where.and.length > 0;
+    const hasOr = Array.isArray(where.or) && where.or.length > 0;
+    if (!(hasProperty && hasOperator && hasValue) && !hasAnd && !hasOr) {
+        return `${fieldName} must have (property, operator, value) or (and/or clauses).`;
+    }
+    return null;
+};
+/**
+ * Validates FIND_NODES template options
+ * Expected: IFindNodesOptions - labels?, where?, properties?, orderBy?, skip?, limit?, returnProperties?
+ */
+const validateFindNodesOptions = (options) => {
+    // At least one search criteria should be present
+    const hasLabels = hasValidValue(options.labels);
+    const hasWhere = hasValidValue(options.where);
+    const hasProperties = hasValidValue(options.properties);
+    if (!hasLabels && !hasWhere && !hasProperties) {
+        return 'FIND_NODES requires at least one of: labels, where, or properties.';
+    }
+    // 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 structure if present
+    if (options.orderBy && !Array.isArray(options.orderBy)) {
+        return 'orderBy must be an array of { property, direction } objects.';
+    }
+    return null;
+};
+/**
+ * Validates FIND_NODE_BY_ID template options
+ * Expected: id (required)
+ */
+const validateFindNodeByIdOptions = (options) => {
+    if (!hasValidValue(options.id)) {
+        return 'FIND_NODE_BY_ID requires id.';
+    }
+    return null;
+};
+/**
+ * Validates CREATE_NODE template options
+ * Expected: ICreateNodeOptions - labels (required), properties (required), returnNode?, onConflict?, uniqueConstraint?
+ */
+const validateCreateNodeOptions = (options) => {
+    if (!hasValidValue(options.labels)) {
+        return 'CREATE_NODE requires labels (string or array of strings).';
+    }
+    if (!hasValidValue(options.properties)) {
+        return 'CREATE_NODE requires properties object.';
+    }
+    // Validate onConflict if present
+    if (options.onConflict && !['error', 'ignore', 'merge'].includes(options.onConflict)) {
+        return 'onConflict must be one of: error, ignore, merge.';
+    }
+    return null;
+};
+/**
+ * Validates UPDATE_NODE template options
+ * Expected: IUpdateNodeOptions - id?, labels?, where?, set?, remove?, addLabels?, removeLabels?, returnNode?
+ */
+const validateUpdateNodeOptions = (options) => {
+    // Must have a way to identify the node(s) to update
+    const hasId = hasValidValue(options.id);
+    const hasLabels = hasValidValue(options.labels);
+    const hasWhere = hasValidValue(options.where);
+    if (!hasId && !hasLabels && !hasWhere) {
+        return 'UPDATE_NODE requires at least one of: id, labels, or where to identify nodes.';
+    }
+    // Must have something to update
+    const hasSet = hasValidValue(options.set);
+    const hasRemove = hasValidValue(options.remove);
+    const hasAddLabels = hasValidValue(options.addLabels);
+    const hasRemoveLabels = hasValidValue(options.removeLabels);
+    if (!hasSet && !hasRemove && !hasAddLabels && !hasRemoveLabels) {
+        return 'UPDATE_NODE requires at least one of: set, remove, addLabels, or removeLabels.';
+    }
+    return null;
+};
+/**
+ * Validates DELETE_NODE template options
+ * Expected: IDeleteNodeOptions - id?, labels?, where?, detach?, returnCount?
+ */
+const validateDeleteNodeOptions = (options) => {
+    const hasId = hasValidValue(options.id);
+    const hasLabels = hasValidValue(options.labels);
+    const hasWhere = hasValidValue(options.where);
+    if (!hasId && !hasLabels && !hasWhere) {
+        return 'DELETE_NODE requires at least one of: id, labels, or where to identify nodes.';
+    }
+    return null;
+};
+/**
+ * Validates MERGE_NODE template options
+ * Expected: IMergeNodeOptions - labels (required), matchProperties (required), onCreate?, onMatch?, returnNode?
+ */
+const validateMergeNodeOptions = (options) => {
+    if (!hasValidValue(options.labels)) {
+        return 'MERGE_NODE requires labels.';
+    }
+    if (!hasValidValue(options.matchProperties)) {
+        return 'MERGE_NODE requires matchProperties to define the merge criteria.';
+    }
+    return null;
+};
+/**
+ * Validates FIND_RELATIONSHIPS template options
+ * Expected: IFindRelationshipsOptions - type?, direction?, fromNode?, toNode?, where?, properties?, orderBy?, skip?, limit?
+ */
+const validateFindRelationshipsOptions = (options) => {
+    const hasType = hasValidValue(options.type);
+    const hasFromNode = hasValidValue(options.fromNode);
+    const hasToNode = hasValidValue(options.toNode);
+    const hasWhere = hasValidValue(options.where);
+    const hasProperties = hasValidValue(options.properties);
+    if (!hasType && !hasFromNode && !hasToNode && !hasWhere && !hasProperties) {
+        return 'FIND_RELATIONSHIPS requires at least one of: type, fromNode, toNode, where, or properties.';
+    }
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    return null;
+};
+/**
+ * Validates CREATE_RELATIONSHIP template options
+ * Expected: ICreateRelationshipOptions - type (required), fromNode (required), toNode (required), properties?, returnRelationship?, onConflict?
+ */
+const validateCreateRelationshipOptions = (options) => {
+    if (!hasValidValue(options.type)) {
+        return 'CREATE_RELATIONSHIP requires type (relationship type string).';
+    }
+    if (!hasValidValue(options.fromNode)) {
+        return 'CREATE_RELATIONSHIP requires fromNode.';
+    }
+    if (!hasValidValue(options.toNode)) {
+        return 'CREATE_RELATIONSHIP requires toNode.';
+    }
+    // Validate node references
+    const fromError = validateNodeReference(options.fromNode, 'fromNode');
+    if (fromError)
+        return fromError;
+    const toError = validateNodeReference(options.toNode, 'toNode');
+    if (toError)
+        return toError;
+    return null;
+};
+/**
+ * Validates UPDATE_RELATIONSHIP template options
+ * Expected: IUpdateRelationshipOptions - id?, type?, fromNode?, toNode?, where?, set?, remove?, returnRelationship?
+ */
+const validateUpdateRelationshipOptions = (options) => {
+    const hasId = hasValidValue(options.id);
+    const hasType = hasValidValue(options.type);
+    const hasFromNode = hasValidValue(options.fromNode);
+    const hasToNode = hasValidValue(options.toNode);
+    const hasWhere = hasValidValue(options.where);
+    if (!hasId && !hasType && !hasFromNode && !hasToNode && !hasWhere) {
+        return 'UPDATE_RELATIONSHIP requires at least one of: id, type, fromNode, toNode, or where to identify relationships.';
+    }
+    const hasSet = hasValidValue(options.set);
+    const hasRemove = hasValidValue(options.remove);
+    if (!hasSet && !hasRemove) {
+        return 'UPDATE_RELATIONSHIP requires at least one of: set or remove.';
+    }
+    return null;
+};
+/**
+ * Validates DELETE_RELATIONSHIP template options
+ * Expected: IDeleteRelationshipOptions - id?, type?, fromNode?, toNode?, where?, returnCount?
+ */
+const validateDeleteRelationshipOptions = (options) => {
+    const hasId = hasValidValue(options.id);
+    const hasType = hasValidValue(options.type);
+    const hasFromNode = hasValidValue(options.fromNode);
+    const hasToNode = hasValidValue(options.toNode);
+    const hasWhere = hasValidValue(options.where);
+    if (!hasId && !hasType && !hasFromNode && !hasToNode && !hasWhere) {
+        return 'DELETE_RELATIONSHIP requires at least one of: id, type, fromNode, toNode, or where to identify relationships.';
+    }
+    return null;
+};
+/**
+ * Validates MERGE_RELATIONSHIP template options
+ * Expected: IMergeRelationshipOptions - type (required), fromNode (required), toNode (required), matchProperties?, onCreate?, onMatch?
+ */
+const validateMergeRelationshipOptions = (options) => {
+    if (!hasValidValue(options.type)) {
+        return 'MERGE_RELATIONSHIP requires type.';
+    }
+    if (!hasValidValue(options.fromNode)) {
+        return 'MERGE_RELATIONSHIP requires fromNode.';
+    }
+    if (!hasValidValue(options.toNode)) {
+        return 'MERGE_RELATIONSHIP requires toNode.';
+    }
+    const fromError = validateNodeReference(options.fromNode, 'fromNode');
+    if (fromError)
+        return fromError;
+    const toError = validateNodeReference(options.toNode, 'toNode');
+    if (toError)
+        return toError;
+    return null;
+};
+/**
+ * Validates TRAVERSE template options
+ * Expected: ITraverseOptions - startNode (required), relationships?, direction?, minDepth?, maxDepth?, uniqueness?, orderBy?, limit?, filters?
+ */
+const validateTraverseOptions = (options) => {
+    if (!hasValidValue(options.startNode)) {
+        return 'TRAVERSE requires startNode.';
+    }
+    const startNodeError = validateNodeReference(options.startNode, 'startNode');
+    if (startNodeError)
+        return startNodeError;
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    // Validate uniqueness if present
+    const validUniqueness = ['NONE', 'NODE_GLOBAL', 'NODE_PATH', 'RELATIONSHIP_GLOBAL', 'RELATIONSHIP_PATH', 'NODE_RECENT'];
+    if (options.uniqueness && !validUniqueness.includes(options.uniqueness)) {
+        return `uniqueness must be one of: ${validUniqueness.join(', ')}.`;
+    }
+    // Validate orderBy (traversal order) if present
+    const validOrders = ['BREADTH_FIRST', 'DEPTH_FIRST'];
+    if (options.orderBy && typeof options.orderBy === 'string' && !validOrders.includes(options.orderBy)) {
+        return `orderBy must be one of: ${validOrders.join(', ')}.`;
+    }
+    return null;
+};
+/**
+ * Validates SHORTEST_PATH template options
+ * Expected: IShortestPathOptions - startNode (required), endNode (required), relationships?, direction?, maxDepth?, weightProperty?, algorithm?
+ */
+const validateShortestPathOptions = (options) => {
+    if (!hasValidValue(options.startNode)) {
+        return 'SHORTEST_PATH requires startNode.';
+    }
+    if (!hasValidValue(options.endNode)) {
+        return 'SHORTEST_PATH requires endNode.';
+    }
+    const startError = validateNodeReference(options.startNode, 'startNode');
+    if (startError)
+        return startError;
+    const endError = validateNodeReference(options.endNode, 'endNode');
+    if (endError)
+        return endError;
+    // Validate algorithm if present
+    const validAlgorithms = ['DIJKSTRA', 'ASTAR', 'BFS', 'ALHOP'];
+    if (options.algorithm && !validAlgorithms.includes(options.algorithm)) {
+        return `algorithm must be one of: ${validAlgorithms.join(', ')}.`;
+    }
+    return null;
+};
+/**
+ * Validates FIND_RELATIONSHIP_BY_ID template options
+ * Expected: id (required)
+ */
+const validateFindRelationshipByIdOptions = (options) => {
+    if (!hasValidValue(options.id)) {
+        return 'FIND_RELATIONSHIP_BY_ID requires id.';
+    }
+    return null;
+};
+/**
+ * Validates ALL_PATHS template options
+ * Expected: IAllPathsOptions - startNode (required), endNode (required), relationships?, direction?, minDepth?, maxDepth?, limit?
+ */
+const validateAllPathsOptions = (options) => {
+    if (!hasValidValue(options.startNode)) {
+        return 'ALL_PATHS requires startNode.';
+    }
+    if (!hasValidValue(options.endNode)) {
+        return 'ALL_PATHS requires endNode.';
+    }
+    const startError = validateNodeReference(options.startNode, 'startNode');
+    if (startError)
+        return startError;
+    const endError = validateNodeReference(options.endNode, 'endNode');
+    if (endError)
+        return endError;
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    return null;
+};
+/**
+ * Validates MATCH_PATTERN template options
+ * Expected: IMatchPatternOptions - pattern (required), return?, orderBy?, skip?, limit?, optional?
+ */
+const validateMatchPatternOptions = (options) => {
+    if (!hasValidValue(options.pattern)) {
+        return 'MATCH_PATTERN requires pattern object.';
+    }
+    // Pattern should have nodes array
+    if (!options.pattern.nodes || !Array.isArray(options.pattern.nodes)) {
+        return 'MATCH_PATTERN pattern must include nodes array.';
+    }
+    return null;
+};
+/**
+ * Validates EXTRACT_SUBGRAPH template options
+ * Expected: ISubgraphOptions - startNodes (required), maxDepth?, relationships?, direction?, includeStartNodes?, nodeFilter?, relationshipFilter?
+ */
+const validateExtractSubgraphOptions = (options) => {
+    if (!hasValidValue(options.startNodes)) {
+        return 'EXTRACT_SUBGRAPH requires startNodes (node selector or array of node selectors).';
+    }
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    return null;
+};
+/**
+ * Validates GET_NEIGHBORHOOD template options
+ * Expected: INeighborhoodOptions - node (required), depth?, direction?, relationshipTypes?, includeCenter?
+ */
+const validateGetNeighborhoodOptions = (options) => {
+    if (!hasValidValue(options.node)) {
+        return 'GET_NEIGHBORHOOD requires node (node selector).';
+    }
+    const nodeError = validateNodeReference(options.node, 'node');
+    if (nodeError)
+        return nodeError;
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    return null;
+};
+/**
+ * Validates CONNECTED_COMPONENTS template options
+ * Expected: IConnectedComponentsOptions - labels?, relationshipTypes?, direction?, minSize?
+ */
+const validateConnectedComponentsOptions = (options) => {
+    // All fields are optional for connected components
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    return null;
+};
+/**
+ * Validates COUNT_NODES template options
+ * Expected: labels?, where?, properties?
+ */
+const validateCountNodesOptions = (options) => {
+    // At least one criteria should be present for meaningful count
+    // But we allow empty to count all nodes
+    // 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 COUNT_RELATIONSHIPS template options
+ * Expected: type?, fromNode?, toNode?, where?, properties?
+ */
+const validateCountRelationshipsOptions = (options) => {
+    // Validate direction if present
+    if (options.direction && !['OUTGOING', 'INCOMING', 'BOTH'].includes(options.direction)) {
+        return 'direction must be one of: OUTGOING, INCOMING, BOTH.';
+    }
+    // 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 FULL_TEXT_SEARCH template options
+ * Expected: IFullTextSearchOptions - index (required), query (required), labels?, score?, limit?, analyzer?
+ */
+const validateFullTextSearchOptions = (options) => {
+    if (!hasValidValue(options.index)) {
+        return 'FULL_TEXT_SEARCH requires index (name of the full-text index).';
+    }
+    if (!hasValidValue(options.query)) {
+        return 'FULL_TEXT_SEARCH requires query (search query string).';
+    }
+    return null;
+};
+/**
+ * Validates VECTOR_SEARCH template options
+ * Expected: IVectorSearchOptions - index (required), vector (required), topK (required), labels?, minScore?
+ */
+const validateVectorSearchOptions = (options) => {
+    if (!hasValidValue(options.index)) {
+        return 'VECTOR_SEARCH requires index (name of the vector index).';
+    }
+    if (!hasValidValue(options.vector)) {
+        return 'VECTOR_SEARCH requires vector (query vector array).';
+    }
+    if (!hasValidValue(options.topK)) {
+        return 'VECTOR_SEARCH requires topK (number of results to return).';
+    }
+    return null;
+};
+/**
+ * Validates RAW_QUERY template options
+ * Expected: IRawQueryOptions - query (required), params?, language?, timeout?, readonly?, database?
+ */
+const validateRawQueryOptions = (options) => {
+    if (!hasValidValue(options.query)) {
+        return 'RAW_QUERY requires query string.';
+    }
+    // Validate language if present
+    const validLanguages = ['CYPHER', 'GREMLIN', 'AQL', 'SPARQL'];
+    if (options.language && !validLanguages.includes(options.language)) {
+        return `language must be one of: ${validLanguages.join(', ')}.`;
+    }
+    return null;
+};
+/**
+ * Validates that the template contains placeholders and has proper structure for the action type
+ */
+const validateGraphTemplate = (value, helpers) => {
+    var _a;
+    if (typeof value !== 'object' || value === null) {
+        return helpers.error('any.invalid', {
+            message: 'Template must be a valid object.',
+        });
+    }
+    const actionType = (_a = helpers.state.ancestors[0]) === null || _a === void 0 ? void 0 : _a.type;
+    // Validate that the template has the correct operation field if specified
+    if (value.operation && value.operation !== actionType) {
+        return helpers.error('any.invalid', {
+            message: `Template operation "${value.operation}" does not match action type "${actionType}".`,
+        });
+    }
+    // Check for placeholders in the template
+    const templateStr = JSON.stringify(value);
+    const placeholders = templateStr.match(placeholderPattern);
+    if (!placeholders || placeholders.length === 0) {
+        return helpers.error('any.invalid', {
+            message: 'Template must include placeholders in the format {{valueName}}.',
+        });
+    }
+    // Ensure options object exists
+    if (!value.options || typeof value.options !== 'object') {
+        return helpers.error('any.invalid', {
+            message: 'Template must include options object.',
+        });
+    }
+    const options = value.options;
+    let validationError = null;
+    // Type-specific validations based on the expected interface for each action type
+    switch (actionType) {
+        // Node operations
+        case productsBuilder_types_1.GraphActionTypes.CREATE_NODE:
+            validationError = validateCreateNodeOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.FIND_NODES:
+            validationError = validateFindNodesOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.FIND_NODE_BY_ID:
+            validationError = validateFindNodeByIdOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.UPDATE_NODE:
+            validationError = validateUpdateNodeOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.DELETE_NODE:
+            validationError = validateDeleteNodeOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.MERGE_NODE:
+            validationError = validateMergeNodeOptions(options);
+            break;
+        // Relationship operations
+        case productsBuilder_types_1.GraphActionTypes.CREATE_RELATIONSHIP:
+            validationError = validateCreateRelationshipOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.FIND_RELATIONSHIPS:
+            validationError = validateFindRelationshipsOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.FIND_RELATIONSHIP_BY_ID:
+            validationError = validateFindRelationshipByIdOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.UPDATE_RELATIONSHIP:
+            validationError = validateUpdateRelationshipOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.DELETE_RELATIONSHIP:
+            validationError = validateDeleteRelationshipOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.MERGE_RELATIONSHIP:
+            validationError = validateMergeRelationshipOptions(options);
+            break;
+        // Traversal and path operations
+        case productsBuilder_types_1.GraphActionTypes.TRAVERSE:
+            validationError = validateTraverseOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.SHORTEST_PATH:
+            validationError = validateShortestPathOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.ALL_PATHS:
+            validationError = validateAllPathsOptions(options);
+            break;
+        // Pattern and subgraph operations
+        case productsBuilder_types_1.GraphActionTypes.MATCH_PATTERN:
+            validationError = validateMatchPatternOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.EXTRACT_SUBGRAPH:
+            validationError = validateExtractSubgraphOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.GET_NEIGHBORHOOD:
+            validationError = validateGetNeighborhoodOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.CONNECTED_COMPONENTS:
+            validationError = validateConnectedComponentsOptions(options);
+            break;
+        // Aggregation operations
+        case productsBuilder_types_1.GraphActionTypes.COUNT_NODES:
+            validationError = validateCountNodesOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.COUNT_RELATIONSHIPS:
+            validationError = validateCountRelationshipsOptions(options);
+            break;
+        // Search operations
+        case productsBuilder_types_1.GraphActionTypes.FULL_TEXT_SEARCH:
+            validationError = validateFullTextSearchOptions(options);
+            break;
+        case productsBuilder_types_1.GraphActionTypes.VECTOR_SEARCH:
+            validationError = validateVectorSearchOptions(options);
+            break;
+        // Raw query
+        case productsBuilder_types_1.GraphActionTypes.RAW_QUERY:
+            validationError = validateRawQueryOptions(options);
+            break;
+        default:
+            validationError = `Unknown action type: ${actionType}`;
+            break;
+    }
+    if (validationError) {
+        return helpers.error('any.invalid', {
+            message: validationError,
+        });
+    }
+    return value;
+};
+exports.validateGraphTemplate = validateGraphTemplate;
+/**
+ * Validates the filter template for update/delete operations
+ */
+const validateGraphFilterTemplate = (value, helpers) => {
+    var _a;
+    if (typeof value !== 'object' || value === null) {
+        return helpers.error('any.invalid', {
+            message: 'FilterTemplate must be a valid 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.GraphActionTypes.UPDATE_NODE,
+        productsBuilder_types_1.GraphActionTypes.DELETE_NODE,
+        productsBuilder_types_1.GraphActionTypes.UPDATE_RELATIONSHIP,
+        productsBuilder_types_1.GraphActionTypes.DELETE_RELATIONSHIP,
+    ].includes(actionType)) {
+        return helpers.error('any.invalid', {
+            message: `FilterTemplate is not applicable for action type "${actionType}".`,
+        });
+    }
+    // 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 must include placeholders in the format {{valueName}}.',
+        });
+    }
+    return value;
+};
+exports.validateGraphFilterTemplate = validateGraphFilterTemplate;
+/**
+ * Schema for creating graph actions
+ */
+exports.GraphActionSchema = 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(),
+    type: Joi.string()
+        .valid(...Object.values(productsBuilder_types_1.GraphActionTypes))
+        .required()
+        .messages({
+        'any.only': `type must be one of: ${Object.values(productsBuilder_types_1.GraphActionTypes).join(', ')}`,
+    }),
+    template: Joi.object()
+        .custom(exports.validateGraphTemplate, 'Graph template validation')
+        .required()
+        .messages({
+        'any.invalid': 'Template must be a valid graph adapter query object with placeholders.',
+    }),
+    filterTemplate: Joi.object()
+        .custom(exports.validateGraphFilterTemplate, 'Graph filter template validation')
+        .optional()
+        .messages({
+        'any.invalid': 'FilterTemplate must be a valid filter object with placeholders.',
+    }),
+});
+exports.default = exports.GraphActionSchema;
+//# sourceMappingURL=create.productGraphAction.validator.js.map