@ductape/sdk 0.0.4-v46 → 0.0.4-v49

package/dist/graph/types/node.types.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Node Types
+ * Defines interfaces for graph nodes (vertices)
+ */
+/**
+ * Property value types supported in graph nodes
+ */
+export type NodePropertyValue = string | number | boolean | Date | string[] | number[] | boolean[] | null | Record<string, any>;
+/**
+ * Node properties type
+ */
+export type NodeProperties = Record<string, NodePropertyValue>;
+/**
+ * Represents a node (vertex) in the graph
+ */
+export interface INode<T extends NodeProperties = NodeProperties> {
+    id: string | number;
+    labels: string[];
+    properties: T;
+    elementId?: string;
+    metadata?: INodeMetadata;
+}
+/**
+ * Node metadata
+ */
+export interface INodeMetadata {
+    createdAt?: Date;
+    updatedAt?: Date;
+    version?: number;
+    source?: string;
+}
+/**
+ * Options for creating a node
+ */
+export interface ICreateNodeOptions<T extends NodeProperties = NodeProperties> {
+    labels: string | string[];
+    properties: T;
+    returnNode?: boolean;
+    onConflict?: 'error' | 'ignore' | 'merge';
+    uniqueConstraint?: {
+        property: string;
+        value: NodePropertyValue;
+    };
+}
+/**
+ * Options for finding nodes
+ */
+export interface IFindNodesOptions {
+    labels?: string | string[];
+    where?: INodeWhereClause;
+    properties?: Partial<NodeProperties>;
+    orderBy?: INodeOrderBy[];
+    skip?: number;
+    limit?: number;
+    returnProperties?: string[];
+}
+/**
+ * Node where clause for filtering
+ */
+export interface INodeWhereClause {
+    property: string;
+    operator: NodeComparisonOperator;
+    value: NodePropertyValue;
+    and?: INodeWhereClause[];
+    or?: INodeWhereClause[];
+}
+/**
+ * Comparison operators for node queries
+ */
+export declare enum NodeComparisonOperator {
+    EQUALS = "=",
+    NOT_EQUALS = "<>",
+    GREATER_THAN = ">",
+    GREATER_THAN_OR_EQUAL = ">=",
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUAL = "<=",
+    IN = "IN",
+    NOT_IN = "NOT IN",
+    CONTAINS = "CONTAINS",
+    STARTS_WITH = "STARTS WITH",
+    ENDS_WITH = "ENDS WITH",
+    IS_NULL = "IS NULL",
+    IS_NOT_NULL = "IS NOT NULL",
+    REGEX = "=~"
+}
+/**
+ * Order by clause for node queries
+ */
+export interface INodeOrderBy {
+    property: string;
+    direction: 'ASC' | 'DESC';
+}
+/**
+ * Options for updating a node
+ */
+export interface IUpdateNodeOptions {
+    id?: string | number;
+    labels?: string | string[];
+    where?: INodeWhereClause;
+    set?: Partial<NodeProperties>;
+    remove?: string[];
+    addLabels?: string[];
+    removeLabels?: string[];
+    returnNode?: boolean;
+}
+/**
+ * Options for deleting nodes
+ */
+export interface IDeleteNodeOptions {
+    id?: string | number;
+    labels?: string | string[];
+    where?: INodeWhereClause;
+    detach?: boolean;
+    returnCount?: boolean;
+}
+/**
+ * Options for merging nodes (MERGE in Cypher)
+ */
+export interface IMergeNodeOptions<T extends NodeProperties = NodeProperties> {
+    labels: string | string[];
+    matchProperties: Partial<T>;
+    onCreate?: Partial<T>;
+    onMatch?: Partial<T>;
+    returnNode?: boolean;
+}
+/**
+ * Node label definition for schema
+ */
+export interface INodeLabelDefinition {
+    name: string;
+    properties?: INodePropertyDefinition[];
+    constraints?: INodeConstraint[];
+    indexes?: INodeIndex[];
+}
+/**
+ * Node property definition for schema
+ */
+export interface INodePropertyDefinition {
+    name: string;
+    type: 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'point' | 'list' | 'map';
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    defaultValue?: NodePropertyValue;
+}
+/**
+ * Node constraint types
+ */
+export declare enum NodeConstraintType {
+    UNIQUE = "UNIQUE",
+    EXISTS = "EXISTS",// Property must exist
+    NODE_KEY = "NODE_KEY"
+}
+/**
+ * Node constraint definition
+ */
+export interface INodeConstraint {
+    name: string;
+    type: NodeConstraintType;
+    properties: string[];
+    label: string;
+}
+/**
+ * Node index types
+ */
+export declare enum NodeIndexType {
+    BTREE = "BTREE",
+    FULLTEXT = "FULLTEXT",
+    POINT = "POINT",// Spatial index
+    RANGE = "RANGE",
+    TEXT = "TEXT",
+    VECTOR = "VECTOR"
+}
+/**
+ * Node index definition
+ */
+export interface INodeIndex {
+    name: string;
+    type: NodeIndexType;
+    properties: string[];
+    label: string;
+    options?: Record<string, any>;
+}
+/**
+ * Batch node operation
+ */
+export interface IBatchNodeOperation<T extends NodeProperties = NodeProperties> {
+    operation: 'create' | 'update' | 'delete' | 'merge';
+    labels?: string | string[];
+    properties?: T;
+    where?: INodeWhereClause;
+    id?: string | number;
+}

package/dist/graph/types/node.types.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Node Types
+ * Defines interfaces for graph nodes (vertices)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeIndexType = exports.NodeConstraintType = exports.NodeComparisonOperator = void 0;
+/**
+ * Comparison operators for node queries
+ */
+var NodeComparisonOperator;
+(function (NodeComparisonOperator) {
+    NodeComparisonOperator["EQUALS"] = "=";
+    NodeComparisonOperator["NOT_EQUALS"] = "<>";
+    NodeComparisonOperator["GREATER_THAN"] = ">";
+    NodeComparisonOperator["GREATER_THAN_OR_EQUAL"] = ">=";
+    NodeComparisonOperator["LESS_THAN"] = "<";
+    NodeComparisonOperator["LESS_THAN_OR_EQUAL"] = "<=";
+    NodeComparisonOperator["IN"] = "IN";
+    NodeComparisonOperator["NOT_IN"] = "NOT IN";
+    NodeComparisonOperator["CONTAINS"] = "CONTAINS";
+    NodeComparisonOperator["STARTS_WITH"] = "STARTS WITH";
+    NodeComparisonOperator["ENDS_WITH"] = "ENDS WITH";
+    NodeComparisonOperator["IS_NULL"] = "IS NULL";
+    NodeComparisonOperator["IS_NOT_NULL"] = "IS NOT NULL";
+    NodeComparisonOperator["REGEX"] = "=~";
+})(NodeComparisonOperator || (exports.NodeComparisonOperator = NodeComparisonOperator = {}));
+/**
+ * Node constraint types
+ */
+var NodeConstraintType;
+(function (NodeConstraintType) {
+    NodeConstraintType["UNIQUE"] = "UNIQUE";
+    NodeConstraintType["EXISTS"] = "EXISTS";
+    NodeConstraintType["NODE_KEY"] = "NODE_KEY";
+})(NodeConstraintType || (exports.NodeConstraintType = NodeConstraintType = {}));
+/**
+ * Node index types
+ */
+var NodeIndexType;
+(function (NodeIndexType) {
+    NodeIndexType["BTREE"] = "BTREE";
+    NodeIndexType["FULLTEXT"] = "FULLTEXT";
+    NodeIndexType["POINT"] = "POINT";
+    NodeIndexType["RANGE"] = "RANGE";
+    NodeIndexType["TEXT"] = "TEXT";
+    NodeIndexType["VECTOR"] = "VECTOR";
+})(NodeIndexType || (exports.NodeIndexType = NodeIndexType = {}));
+//# sourceMappingURL=node.types.js.map

package/dist/graph/types/node.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.types.js","sourceRoot":"","sources":["../../../src/graph/types/node.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAgFH;;GAEG;AACH,IAAY,sBAeX;AAfD,WAAY,sBAAsB;IAChC,sCAAY,CAAA;IACZ,2CAAiB,CAAA;IACjB,4CAAkB,CAAA;IAClB,sDAA4B,CAAA;IAC5B,yCAAe,CAAA;IACf,mDAAyB,CAAA;IACzB,mCAAS,CAAA;IACT,2CAAiB,CAAA;IACjB,+CAAqB,CAAA;IACrB,qDAA2B,CAAA;IAC3B,iDAAuB,CAAA;IACvB,6CAAmB,CAAA;IACnB,qDAA2B,CAAA;IAC3B,sCAAY,CAAA;AACd,CAAC,EAfW,sBAAsB,sCAAtB,sBAAsB,QAejC;AAoED;;GAEG;AACH,IAAY,kBAIX;AAJD,WAAY,kBAAkB;IAC5B,uCAAiB,CAAA;IACjB,uCAAiB,CAAA;IACjB,2CAAqB,CAAA;AACvB,CAAC,EAJW,kBAAkB,kCAAlB,kBAAkB,QAI7B;AAYD;;GAEG;AACH,IAAY,aAOX;AAPD,WAAY,aAAa;IACvB,gCAAe,CAAA;IACf,sCAAqB,CAAA;IACrB,gCAAe,CAAA;IACf,gCAAe,CAAA;IACf,8BAAa,CAAA;IACb,kCAAiB,CAAA;AACnB,CAAC,EAPW,aAAa,6BAAb,aAAa,QAOxB"}

package/dist/graph/types/path.types.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Path and Traversal Types
+ * Defines interfaces for graph paths, traversals, and pattern matching
+ */
+import { INode, NodeProperties, INodeWhereClause } from './node.types';
+import { IRelationship, RelationshipProperties, RelationshipDirection, IRelationshipPattern, IRelationshipWhereClause } from './relationship.types';
+/**
+ * Represents a path in the graph
+ */
+export interface IPath<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties> {
+    nodes: INode<N>[];
+    relationships: IRelationship<R>[];
+    length: number;
+    start: INode<N>;
+    end: INode<N>;
+}
+/**
+ * Weighted path with cost information
+ */
+export interface IWeightedPath<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties> extends IPath<N, R> {
+    totalWeight: number;
+    weights: number[];
+}
+/**
+ * Options for traversing the graph
+ */
+export interface ITraverseOptions {
+    startNode: INodeSelector;
+    relationships?: IRelationshipPattern | IRelationshipPattern[];
+    direction?: RelationshipDirection;
+    minDepth?: number;
+    maxDepth?: number;
+    uniqueness?: TraversalUniqueness;
+    orderBy?: TraversalOrder;
+    limit?: number;
+    filters?: ITraversalFilter;
+    returnPaths?: boolean;
+    returnNodes?: boolean;
+}
+/**
+ * Node selector for traversal start point
+ */
+export interface INodeSelector {
+    id?: string | number;
+    labels?: string | string[];
+    properties?: Partial<NodeProperties>;
+    where?: INodeWhereClause;
+}
+/**
+ * Traversal uniqueness constraints
+ */
+export declare enum TraversalUniqueness {
+    NONE = "NONE",// No restrictions
+    NODE_GLOBAL = "NODE_GLOBAL",// Each node visited once globally
+    NODE_PATH = "NODE_PATH",// Each node visited once per path
+    RELATIONSHIP_GLOBAL = "RELATIONSHIP_GLOBAL",// Each relationship traversed once globally
+    RELATIONSHIP_PATH = "RELATIONSHIP_PATH",// Each relationship traversed once per path
+    NODE_RECENT = "NODE_RECENT"
+}
+/**
+ * Traversal ordering
+ */
+export declare enum TraversalOrder {
+    BREADTH_FIRST = "BREADTH_FIRST",
+    DEPTH_FIRST = "DEPTH_FIRST"
+}
+/**
+ * Traversal filter options
+ */
+export interface ITraversalFilter {
+    nodeLabels?: string[];
+    nodeWhere?: INodeWhereClause;
+    relationshipTypes?: string[];
+    relationshipWhere?: IRelationshipWhereClause;
+    stopAtLabels?: string[];
+    stopAtDepth?: number;
+}
+/**
+ * Options for finding shortest path
+ */
+export interface IShortestPathOptions {
+    startNode: INodeSelector;
+    endNode: INodeSelector;
+    relationships?: IRelationshipPattern | IRelationshipPattern[];
+    direction?: RelationshipDirection;
+    maxDepth?: number;
+    weightProperty?: string;
+    defaultWeight?: number;
+    algorithm?: PathAlgorithm;
+    returnAllShortest?: boolean;
+}
+/**
+ * Supported pathfinding algorithms
+ */
+export declare enum PathAlgorithm {
+    DIJKSTRA = "DIJKSTRA",
+    ASTAR = "ASTAR",
+    BFS = "BFS",
+    ALHOP = "ALHOP"
+}
+/**
+ * Options for finding all paths
+ */
+export interface IAllPathsOptions {
+    startNode: INodeSelector;
+    endNode: INodeSelector;
+    relationships?: IRelationshipPattern | IRelationshipPattern[];
+    direction?: RelationshipDirection;
+    minDepth?: number;
+    maxDepth?: number;
+    limit?: number;
+}
+/**
+ * Graph pattern for pattern matching
+ */
+export interface IGraphPattern {
+    nodes: INodePattern[];
+    relationships: IRelationshipPatternDef[];
+    where?: IPatternWhereClause;
+    optional?: boolean;
+}
+/**
+ * Node pattern in graph pattern matching
+ */
+export interface INodePattern {
+    variable: string;
+    labels?: string | string[];
+    properties?: Partial<NodeProperties>;
+    where?: INodeWhereClause;
+}
+/**
+ * Relationship pattern in graph pattern matching
+ */
+export interface IRelationshipPatternDef {
+    variable?: string;
+    type?: string | string[];
+    startNode: string;
+    endNode: string;
+    direction?: RelationshipDirection;
+    properties?: Partial<RelationshipProperties>;
+    where?: IRelationshipWhereClause;
+    minHops?: number;
+    maxHops?: number;
+}
+/**
+ * Where clause for pattern matching
+ */
+export interface IPatternWhereClause {
+    conditions: IPatternCondition[];
+    operator?: 'AND' | 'OR';
+}
+/**
+ * Individual pattern condition
+ */
+export interface IPatternCondition {
+    expression: string;
+    params?: Record<string, any>;
+}
+/**
+ * Options for pattern matching
+ */
+export interface IMatchPatternOptions {
+    pattern: IGraphPattern;
+    return?: string[];
+    orderBy?: IPatternOrderBy[];
+    skip?: number;
+    limit?: number;
+    optional?: boolean;
+}
+/**
+ * Order by for pattern results
+ */
+export interface IPatternOrderBy {
+    expression: string;
+    direction: 'ASC' | 'DESC';
+}
+/**
+ * Subgraph extraction options
+ */
+export interface ISubgraphOptions {
+    startNodes: INodeSelector | INodeSelector[];
+    maxDepth?: number;
+    relationships?: IRelationshipPattern | IRelationshipPattern[];
+    direction?: RelationshipDirection;
+    includeStartNodes?: boolean;
+    nodeFilter?: INodeWhereClause;
+    relationshipFilter?: IRelationshipWhereClause;
+}
+/**
+ * Represents an extracted subgraph
+ */
+export interface ISubgraph<N extends NodeProperties = NodeProperties, R extends RelationshipProperties = RelationshipProperties> {
+    nodes: INode<N>[];
+    relationships: IRelationship<R>[];
+    nodeCount: number;
+    relationshipCount: number;
+}
+/**
+ * Neighborhood options
+ */
+export interface INeighborhoodOptions {
+    node: INodeSelector;
+    depth?: number;
+    direction?: RelationshipDirection;
+    relationshipTypes?: string[];
+    includeCenter?: boolean;
+}
+/**
+ * Connected components options
+ */
+export interface IConnectedComponentsOptions {
+    labels?: string[];
+    relationshipTypes?: string[];
+    direction?: RelationshipDirection;
+    minSize?: number;
+}
+/**
+ * Represents a connected component
+ */
+export interface IConnectedComponent<N extends NodeProperties = NodeProperties> {
+    id: number;
+    nodes: INode<N>[];
+    size: number;
+}

package/dist/graph/types/path.types.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Path and Traversal Types
+ * Defines interfaces for graph paths, traversals, and pattern matching
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathAlgorithm = exports.TraversalOrder = exports.TraversalUniqueness = void 0;
+/**
+ * Traversal uniqueness constraints
+ */
+var TraversalUniqueness;
+(function (TraversalUniqueness) {
+    TraversalUniqueness["NONE"] = "NONE";
+    TraversalUniqueness["NODE_GLOBAL"] = "NODE_GLOBAL";
+    TraversalUniqueness["NODE_PATH"] = "NODE_PATH";
+    TraversalUniqueness["RELATIONSHIP_GLOBAL"] = "RELATIONSHIP_GLOBAL";
+    TraversalUniqueness["RELATIONSHIP_PATH"] = "RELATIONSHIP_PATH";
+    TraversalUniqueness["NODE_RECENT"] = "NODE_RECENT";
+})(TraversalUniqueness || (exports.TraversalUniqueness = TraversalUniqueness = {}));
+/**
+ * Traversal ordering
+ */
+var TraversalOrder;
+(function (TraversalOrder) {
+    TraversalOrder["BREADTH_FIRST"] = "BREADTH_FIRST";
+    TraversalOrder["DEPTH_FIRST"] = "DEPTH_FIRST";
+})(TraversalOrder || (exports.TraversalOrder = TraversalOrder = {}));
+/**
+ * Supported pathfinding algorithms
+ */
+var PathAlgorithm;
+(function (PathAlgorithm) {
+    PathAlgorithm["DIJKSTRA"] = "DIJKSTRA";
+    PathAlgorithm["ASTAR"] = "ASTAR";
+    PathAlgorithm["BFS"] = "BFS";
+    PathAlgorithm["ALHOP"] = "ALHOP";
+})(PathAlgorithm || (exports.PathAlgorithm = PathAlgorithm = {}));
+//# sourceMappingURL=path.types.js.map

package/dist/graph/types/path.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.types.js","sourceRoot":"","sources":["../../../src/graph/types/path.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAyDH;;GAEG;AACH,IAAY,mBAOX;AAPD,WAAY,mBAAmB;IAC7B,oCAAa,CAAA;IACb,kDAA2B,CAAA;IAC3B,8CAAuB,CAAA;IACvB,kEAA2C,CAAA;IAC3C,8DAAuC,CAAA;IACvC,kDAA2B,CAAA;AAC7B,CAAC,EAPW,mBAAmB,mCAAnB,mBAAmB,QAO9B;AAED;;GAEG;AACH,IAAY,cAGX;AAHD,WAAY,cAAc;IACxB,iDAA+B,CAAA;IAC/B,6CAA2B,CAAA;AAC7B,CAAC,EAHW,cAAc,8BAAd,cAAc,QAGzB;AA6BD;;GAEG;AACH,IAAY,aAKX;AALD,WAAY,aAAa;IACvB,sCAAqB,CAAA;IACrB,gCAAe,CAAA;IACf,4BAAW,CAAA;IACX,gCAAe,CAAA;AACjB,CAAC,EALW,aAAa,6BAAb,aAAa,QAKxB"}