@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,247 @@
+/**
+ * Query Types
+ * Defines interfaces for graph query operations
+ */
+import { GraphQueryLanguage } from './graph.types';
+import { GraphConnectionConfig, IProductGraphConfig } from './connection.types';
+/**
+ * Raw query options
+ */
+export interface IRawQueryOptions {
+    query: string;
+    params?: Record<string, any>;
+    language?: GraphQueryLanguage;
+    timeout?: number;
+    readonly?: boolean;
+    database?: string;
+}
+/**
+ * Query execution context
+ */
+export interface IQueryContext {
+    config: GraphConnectionConfig | IProductGraphConfig;
+    transactionId?: string;
+    sessionId?: string;
+}
+/**
+ * Cypher-specific query options
+ */
+export interface ICypherQueryOptions extends IRawQueryOptions {
+    language: GraphQueryLanguage.CYPHER;
+    profile?: boolean;
+    explain?: boolean;
+}
+/**
+ * Gremlin-specific query options
+ */
+export interface IGremlinQueryOptions extends IRawQueryOptions {
+    language: GraphQueryLanguage.GREMLIN;
+    bindings?: Record<string, any>;
+    evaluationTimeout?: number;
+}
+/**
+ * AQL (ArangoDB)-specific query options
+ */
+export interface IAQLQueryOptions extends IRawQueryOptions {
+    language: GraphQueryLanguage.AQL;
+    count?: boolean;
+    batchSize?: number;
+    cache?: boolean;
+    memoryLimit?: number;
+    ttl?: number;
+    fullCount?: boolean;
+    optimizer?: {
+        rules?: string[];
+    };
+}
+/**
+ * Union type for language-specific query options
+ */
+export type LanguageQueryOptions = ICypherQueryOptions | IGremlinQueryOptions | IAQLQueryOptions | IRawQueryOptions;
+/**
+ * Query statistics
+ */
+export interface IQueryStatistics {
+    nodesCreated?: number;
+    nodesDeleted?: number;
+    relationshipsCreated?: number;
+    relationshipsDeleted?: number;
+    propertiesSet?: number;
+    labelsAdded?: number;
+    labelsRemoved?: number;
+    indexesAdded?: number;
+    indexesRemoved?: number;
+    constraintsAdded?: number;
+    constraintsRemoved?: number;
+    containsUpdates: boolean;
+    containsSystemUpdates?: boolean;
+}
+/**
+ * Query plan information
+ */
+export interface IQueryPlan {
+    operatorType: string;
+    arguments?: Record<string, any>;
+    identifiers?: string[];
+    children?: IQueryPlan[];
+    rows?: number;
+    estimatedRows?: number;
+    dbHits?: number;
+    pageCacheHits?: number;
+    pageCacheMisses?: number;
+    time?: number;
+}
+/**
+ * Query profile information
+ */
+export interface IQueryProfile extends IQueryPlan {
+    actualRows: number;
+    actualDbHits: number;
+    actualTime: number;
+    memory?: number;
+}
+/**
+ * Query notification (warnings/hints)
+ */
+export interface IQueryNotification {
+    code: string;
+    title: string;
+    description: string;
+    severity: 'WARNING' | 'INFORMATION' | 'HINT';
+    position?: {
+        offset?: number;
+        line?: number;
+        column?: number;
+    };
+}
+/**
+ * Query metadata
+ */
+export interface IQueryMetadata {
+    statistics?: IQueryStatistics;
+    plan?: IQueryPlan;
+    profile?: IQueryProfile;
+    notifications?: IQueryNotification[];
+    executionTime: number;
+    dbHits?: number;
+    serverVersion?: string;
+    queryLanguage: GraphQueryLanguage;
+}
+/**
+ * Aggregation function types
+ */
+export declare enum AggregationFunction {
+    COUNT = "COUNT",
+    SUM = "SUM",
+    AVG = "AVG",
+    MIN = "MIN",
+    MAX = "MAX",
+    COLLECT = "COLLECT",
+    STDEV = "STDEV",
+    PERCENTILE_CONT = "PERCENTILE_CONT",
+    PERCENTILE_DISC = "PERCENTILE_DISC"
+}
+/**
+ * Aggregation options
+ */
+export interface IAggregationOptions {
+    function: AggregationFunction;
+    property?: string;
+    alias?: string;
+    distinct?: boolean;
+    percentile?: number;
+}
+/**
+ * Group by options for graph queries
+ */
+export interface IGraphGroupByOptions {
+    groupBy: string[];
+    aggregations: IAggregationOptions[];
+    having?: IHavingClause;
+    orderBy?: IGraphOrderBy[];
+    limit?: number;
+}
+/**
+ * Having clause for aggregation filtering
+ */
+export interface IHavingClause {
+    aggregation: AggregationFunction;
+    property?: string;
+    operator: '=' | '<>' | '>' | '>=' | '<' | '<=';
+    value: number;
+}
+/**
+ * Order by for graph queries
+ */
+export interface IGraphOrderBy {
+    expression: string;
+    direction: 'ASC' | 'DESC';
+    nulls?: 'FIRST' | 'LAST';
+}
+/**
+ * Pagination options
+ */
+export interface IPaginationOptions {
+    skip?: number;
+    limit?: number;
+    cursor?: string;
+}
+/**
+ * Full-text search options
+ */
+export interface IFullTextSearchOptions {
+    index: string;
+    query: string;
+    labels?: string[];
+    score?: boolean;
+    limit?: number;
+    analyzer?: string;
+}
+/**
+ * Vector search options (for vector indexes)
+ */
+export interface IVectorSearchOptions {
+    index: string;
+    vector: number[];
+    topK: number;
+    labels?: string[];
+    minScore?: number;
+}
+/**
+ * Batch query options
+ */
+export interface IBatchQueryOptions {
+    queries: IRawQueryOptions[];
+    sequential?: boolean;
+    stopOnError?: boolean;
+    transactional?: boolean;
+}
+/**
+ * Query template definition
+ */
+export interface IQueryTemplate {
+    name: string;
+    query: string;
+    language: GraphQueryLanguage;
+    parameters?: IQueryParameterDefinition[];
+    description?: string;
+}
+/**
+ * Query parameter definition
+ */
+export interface IQueryParameterDefinition {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date';
+    required?: boolean;
+    defaultValue?: any;
+    description?: string;
+}
+/**
+ * Prepared query (with bound parameters)
+ */
+export interface IPreparedQuery {
+    template: IQueryTemplate;
+    params: Record<string, any>;
+    validate(): boolean;
+    execute<T = any>(): Promise<T>;
+}

package/dist/graph/types/query.types.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Query Types
+ * Defines interfaces for graph query operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationFunction = void 0;
+/**
+ * Aggregation function types
+ */
+var AggregationFunction;
+(function (AggregationFunction) {
+    AggregationFunction["COUNT"] = "COUNT";
+    AggregationFunction["SUM"] = "SUM";
+    AggregationFunction["AVG"] = "AVG";
+    AggregationFunction["MIN"] = "MIN";
+    AggregationFunction["MAX"] = "MAX";
+    AggregationFunction["COLLECT"] = "COLLECT";
+    AggregationFunction["STDEV"] = "STDEV";
+    AggregationFunction["PERCENTILE_CONT"] = "PERCENTILE_CONT";
+    AggregationFunction["PERCENTILE_DISC"] = "PERCENTILE_DISC";
+})(AggregationFunction || (exports.AggregationFunction = AggregationFunction = {}));
+//# sourceMappingURL=query.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.types.js","sourceRoot":"","sources":["../../../src/graph/types/query.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA+IH;;GAEG;AACH,IAAY,mBAUX;AAVD,WAAY,mBAAmB;IAC7B,sCAAe,CAAA;IACf,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,0CAAmB,CAAA;IACnB,sCAAe,CAAA;IACf,0DAAmC,CAAA;IACnC,0DAAmC,CAAA;AACrC,CAAC,EAVW,mBAAmB,mCAAnB,mBAAmB,QAU9B"}

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

@@ -0,0 +1,224 @@
+/**
+ * Relationship Types
+ * Defines interfaces for graph relationships (edges)
+ */
+import { INode, NodeProperties, NodePropertyValue, NodeComparisonOperator } from './node.types';
+/**
+ * Relationship property types
+ */
+export type RelationshipPropertyValue = NodePropertyValue;
+export type RelationshipProperties = Record<string, RelationshipPropertyValue>;
+/**
+ * Represents a relationship (edge) in the graph
+ */
+export interface IRelationship<T extends RelationshipProperties = RelationshipProperties> {
+    id: string | number;
+    type: string;
+    startNodeId: string | number;
+    endNodeId: string | number;
+    properties: T;
+    elementId?: string;
+    startNodeElementId?: string;
+    endNodeElementId?: string;
+    metadata?: IRelationshipMetadata;
+}
+/**
+ * Relationship with attached nodes
+ */
+export interface IRelationshipWithNodes<R extends RelationshipProperties = RelationshipProperties, S extends NodeProperties = NodeProperties, E extends NodeProperties = NodeProperties> extends IRelationship<R> {
+    startNode: INode<S>;
+    endNode: INode<E>;
+}
+/**
+ * Relationship metadata
+ */
+export interface IRelationshipMetadata {
+    createdAt?: Date;
+    updatedAt?: Date;
+    weight?: number;
+    version?: number;
+}
+/**
+ * Relationship direction
+ */
+export declare enum RelationshipDirection {
+    OUTGOING = "OUTGOING",// (a)-[r]->(b)
+    INCOMING = "INCOMING",// (a)<-[r]-(b)
+    BOTH = "BOTH"
+}
+/**
+ * Options for creating a relationship
+ */
+export interface ICreateRelationshipOptions<T extends RelationshipProperties = RelationshipProperties> {
+    type: string;
+    fromNode: INodeReference;
+    toNode: INodeReference;
+    properties?: T;
+    returnRelationship?: boolean;
+    onConflict?: 'error' | 'ignore' | 'merge';
+}
+/**
+ * Reference to a node (for relationship endpoints)
+ */
+export interface INodeReference {
+    id?: string | number;
+    labels?: string | string[];
+    properties?: Partial<NodeProperties>;
+    where?: IRelationshipNodeWhere;
+}
+/**
+ * Node where clause in relationship context
+ */
+export interface IRelationshipNodeWhere {
+    property: string;
+    operator: NodeComparisonOperator;
+    value: NodePropertyValue;
+}
+/**
+ * Options for finding relationships
+ */
+export interface IFindRelationshipsOptions {
+    type?: string | string[];
+    direction?: RelationshipDirection;
+    fromNode?: INodeReference;
+    toNode?: INodeReference;
+    where?: IRelationshipWhereClause;
+    properties?: Partial<RelationshipProperties>;
+    orderBy?: IRelationshipOrderBy[];
+    skip?: number;
+    limit?: number;
+    returnProperties?: string[];
+    includeNodes?: boolean;
+}
+/**
+ * Relationship where clause
+ */
+export interface IRelationshipWhereClause {
+    property: string;
+    operator: NodeComparisonOperator;
+    value: RelationshipPropertyValue;
+    and?: IRelationshipWhereClause[];
+    or?: IRelationshipWhereClause[];
+}
+/**
+ * Order by for relationship queries
+ */
+export interface IRelationshipOrderBy {
+    property: string;
+    direction: 'ASC' | 'DESC';
+}
+/**
+ * Options for updating a relationship
+ */
+export interface IUpdateRelationshipOptions {
+    id?: string | number;
+    type?: string;
+    fromNode?: INodeReference;
+    toNode?: INodeReference;
+    where?: IRelationshipWhereClause;
+    set?: Partial<RelationshipProperties>;
+    remove?: string[];
+    returnRelationship?: boolean;
+}
+/**
+ * Options for deleting relationships
+ */
+export interface IDeleteRelationshipOptions {
+    id?: string | number;
+    type?: string | string[];
+    fromNode?: INodeReference;
+    toNode?: INodeReference;
+    where?: IRelationshipWhereClause;
+    returnCount?: boolean;
+}
+/**
+ * Options for merging relationships
+ */
+export interface IMergeRelationshipOptions<T extends RelationshipProperties = RelationshipProperties> {
+    type: string;
+    fromNode: INodeReference;
+    toNode: INodeReference;
+    matchProperties?: Partial<T>;
+    onCreate?: Partial<T>;
+    onMatch?: Partial<T>;
+    returnRelationship?: boolean;
+}
+/**
+ * Relationship type definition for schema
+ */
+export interface IRelationshipTypeDefinition {
+    type: string;
+    properties?: IRelationshipPropertyDefinition[];
+    constraints?: IRelationshipConstraint[];
+    indexes?: IRelationshipIndex[];
+    validStartLabels?: string[];
+    validEndLabels?: string[];
+}
+/**
+ * Relationship property definition
+ */
+export interface IRelationshipPropertyDefinition {
+    name: string;
+    type: 'string' | 'integer' | 'float' | 'boolean' | 'date' | 'datetime' | 'list' | 'map';
+    required?: boolean;
+    indexed?: boolean;
+    defaultValue?: RelationshipPropertyValue;
+}
+/**
+ * Relationship constraint types
+ */
+export declare enum RelationshipConstraintType {
+    EXISTS = "EXISTS",
+    UNIQUE = "UNIQUE"
+}
+/**
+ * Relationship constraint definition
+ */
+export interface IRelationshipConstraint {
+    name: string;
+    type: RelationshipConstraintType;
+    properties: string[];
+    relationshipType: string;
+}
+/**
+ * Relationship index types
+ */
+export declare enum RelationshipIndexType {
+    BTREE = "BTREE",
+    FULLTEXT = "FULLTEXT",
+    RANGE = "RANGE",
+    TEXT = "TEXT"
+}
+/**
+ * Relationship index definition
+ */
+export interface IRelationshipIndex {
+    name: string;
+    type: RelationshipIndexType;
+    properties: string[];
+    relationshipType: string;
+    options?: Record<string, any>;
+}
+/**
+ * Batch relationship operation
+ */
+export interface IBatchRelationshipOperation<T extends RelationshipProperties = RelationshipProperties> {
+    operation: 'create' | 'update' | 'delete' | 'merge';
+    type?: string;
+    fromNode?: INodeReference;
+    toNode?: INodeReference;
+    properties?: T;
+    where?: IRelationshipWhereClause;
+    id?: string | number;
+}
+/**
+ * Relationship pattern for pattern matching
+ */
+export interface IRelationshipPattern {
+    variable?: string;
+    type?: string | string[];
+    direction?: RelationshipDirection;
+    properties?: Partial<RelationshipProperties>;
+    minHops?: number;
+    maxHops?: number;
+}

package/dist/graph/types/relationship.types.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Relationship Types
+ * Defines interfaces for graph relationships (edges)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RelationshipIndexType = exports.RelationshipConstraintType = exports.RelationshipDirection = void 0;
+/**
+ * Relationship direction
+ */
+var RelationshipDirection;
+(function (RelationshipDirection) {
+    RelationshipDirection["OUTGOING"] = "OUTGOING";
+    RelationshipDirection["INCOMING"] = "INCOMING";
+    RelationshipDirection["BOTH"] = "BOTH";
+})(RelationshipDirection || (exports.RelationshipDirection = RelationshipDirection = {}));
+/**
+ * Relationship constraint types
+ */
+var RelationshipConstraintType;
+(function (RelationshipConstraintType) {
+    RelationshipConstraintType["EXISTS"] = "EXISTS";
+    RelationshipConstraintType["UNIQUE"] = "UNIQUE";
+})(RelationshipConstraintType || (exports.RelationshipConstraintType = RelationshipConstraintType = {}));
+/**
+ * Relationship index types
+ */
+var RelationshipIndexType;
+(function (RelationshipIndexType) {
+    RelationshipIndexType["BTREE"] = "BTREE";
+    RelationshipIndexType["FULLTEXT"] = "FULLTEXT";
+    RelationshipIndexType["RANGE"] = "RANGE";
+    RelationshipIndexType["TEXT"] = "TEXT";
+})(RelationshipIndexType || (exports.RelationshipIndexType = RelationshipIndexType = {}));
+//# sourceMappingURL=relationship.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relationship.types.js","sourceRoot":"","sources":["../../../src/graph/types/relationship.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA+CH;;GAEG;AACH,IAAY,qBAIX;AAJD,WAAY,qBAAqB;IAC/B,8CAAqB,CAAA;IACrB,8CAAqB,CAAA;IACrB,sCAAa,CAAA;AACf,CAAC,EAJW,qBAAqB,qCAArB,qBAAqB,QAIhC;AAmID;;GAEG;AACH,IAAY,0BAGX;AAHD,WAAY,0BAA0B;IACpC,+CAAiB,CAAA;IACjB,+CAAiB,CAAA;AACnB,CAAC,EAHW,0BAA0B,0CAA1B,0BAA0B,QAGrC;AAYD;;GAEG;AACH,IAAY,qBAKX;AALD,WAAY,qBAAqB;IAC/B,wCAAe,CAAA;IACf,8CAAqB,CAAA;IACrB,wCAAe,CAAA;IACf,sCAAa,CAAA;AACf,CAAC,EALW,qBAAqB,qCAArB,qBAAqB,QAKhC"}