@ductape/sdk 0.0.4-v51 → 0.0.4-v52

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

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