@ductape/sdk 0.0.4-v6 → 0.0.4-v61

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

@@ -0,0 +1,175 @@
+/**
+ * Graph Query Interfaces
+ *
+ * Types for query operations and filter clauses
+ * Based on Ductape Graph API documentation (nodes.md, overview.md)
+ */
+/**
+ * Filter operators for graph queries
+ * As documented in nodes.md
+ * Uses lowercase naming convention to match Mongoose/MongoDB style for less adoption friction
+ * Note: Uppercase versions are still supported for backwards compatibility
+ */
+export interface IGraphFilterOperator {
+    /** Greater than */
+    $gt?: number | Date;
+    /** Greater than or equal */
+    $gte?: number | Date;
+    /** Less than */
+    $lt?: number | Date;
+    /** Less than or equal */
+    $lte?: number | Date;
+    /** Not equal */
+    $ne?: any;
+    /** In array */
+    $in?: any[];
+    /** Not in array */
+    $nin?: any[];
+    /** String contains */
+    $contains?: string;
+    /** String starts with */
+    $startsWith?: string;
+    /** String ends with */
+    $endsWith?: string;
+    /** Property exists */
+    $exists?: boolean;
+    /** Regular expression match */
+    $regex?: string | RegExp;
+}
+/**
+ * Where clause for filtering
+ * As documented in nodes.md
+ * Uses lowercase naming convention to match Mongoose/MongoDB style
+ */
+export interface IGraphWhereClause {
+    /** AND conditions */
+    $and?: IGraphWhereClause[] | IGraphWhereClause;
+    /** OR conditions */
+    $or?: IGraphWhereClause[] | IGraphWhereClause;
+    /** NOT conditions */
+    $not?: IGraphWhereClause;
+    /** Property conditions */
+    [key: string]: any | IGraphFilterOperator | IGraphWhereClause | IGraphWhereClause[] | undefined;
+}
+/**
+ * Raw query options
+ * As documented in overview.md
+ */
+export interface IRawQueryOptions {
+    /** The query string (Cypher, Gremlin, AQL) */
+    query: string;
+    /** Query parameters */
+    params?: Record<string, any>;
+    /** Connection context override */
+    env?: string;
+    /** Graph tag override */
+    graph?: string;
+}
+/**
+ * Raw query result
+ */
+export interface IRawQueryResult<T = any> {
+    /** Query results */
+    records: T[];
+    /** Summary information */
+    summary?: {
+        /** Query execution time */
+        resultAvailableAfter?: number;
+        /** Query consumption time */
+        resultConsumedAfter?: number;
+        /** Database info */
+        database?: string;
+    };
+}
+/**
+ * Count nodes options
+ * As documented in overview.md
+ */
+export interface ICountNodesOptions {
+    /** Node labels to count */
+    labels?: string[];
+    /** Filter conditions */
+    where?: IGraphWhereClause;
+}
+/**
+ * Count nodes result
+ */
+export interface ICountNodesResult {
+    /** Count of matching nodes */
+    count: number;
+}
+/**
+ * Count relationships options
+ * As documented in overview.md
+ */
+export interface ICountRelationshipsOptions {
+    /** Relationship types to count */
+    types?: string[];
+    /** Filter conditions */
+    where?: IGraphWhereClause;
+}
+/**
+ * Count relationships result
+ */
+export interface ICountRelationshipsResult {
+    /** Count of matching relationships */
+    count: number;
+}
+/**
+ * Graph statistics
+ * As documented in overview.md
+ */
+export interface IGraphStatistics {
+    /** Total number of nodes */
+    nodeCount: number;
+    /** Total number of relationships */
+    relationshipCount: number;
+    /** Node count by label */
+    nodesByLabel?: Record<string, number>;
+    /** Relationship count by type */
+    relationshipsByType?: Record<string, number>;
+}
+/**
+ * Full-text search options
+ * As documented in overview.md
+ */
+export interface IFullTextSearchOptions {
+    /** Index name */
+    indexName: string;
+    /** Search query */
+    query: string;
+    /** Maximum results */
+    limit?: number;
+}
+/**
+ * Full-text search result
+ */
+export interface IFullTextSearchResult<T = any> {
+    /** Matching nodes */
+    nodes: T[];
+    /** Search scores */
+    scores?: number[];
+}
+/**
+ * Vector search options
+ * As documented in overview.md
+ */
+export interface IVectorSearchOptions {
+    /** Index name */
+    indexName: string;
+    /** Search vector */
+    vector: number[];
+    /** Number of results (top-k) */
+    topK?: number;
+    /** Minimum similarity threshold */
+    minScore?: number;
+}
+/**
+ * Vector search result
+ */
+export interface IVectorSearchResult<T = any> {
+    /** Matching nodes */
+    nodes: T[];
+    /** Similarity scores */
+    scores: number[];
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Graph Query Interfaces
+ *
+ * Types for query operations and filter clauses
+ * Based on Ductape Graph API documentation (nodes.md, overview.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=query.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.interface.js","sourceRoot":"","sources":["../../../src/graph/types/query.interface.ts"],"names":[],"mappings":";AAAA;;;;;GAKG"}

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

@@ -0,0 +1,207 @@
+/**
+ * Graph Relationship Interfaces
+ *
+ * Types for relationship CRUD operations
+ * Based on Ductape Graph API documentation (relationships.md, overview.md)
+ */
+import { IGraphWhereClause } from './query.interface';
+/**
+ * Generic relationship properties type
+ */
+export type RelationshipProperties = Record<string, any>;
+/**
+ * Relationship structure
+ * As documented in relationships.md
+ */
+export interface IRelationship<T = RelationshipProperties> {
+    /** Database-specific ID */
+    id: string | number;
+    /** Relationship type */
+    type: string;
+    /** Source node ID */
+    startNodeId: string | number;
+    /** Target node ID */
+    endNodeId: string | number;
+    /** Relationship properties */
+    properties: T;
+    /** Neo4j 5.x element ID */
+    elementId?: string;
+}
+/**
+ * Options for creating a relationship
+ * As documented in relationships.md
+ */
+export interface ICreateRelationshipOptions<T = RelationshipProperties> {
+    /** Relationship type (e.g., 'FRIENDS_WITH', 'MANAGES') */
+    type: string;
+    /** Source node ID */
+    startNodeId: string | number;
+    /** Target node ID */
+    endNodeId: string | number;
+    /** Relationship properties */
+    properties?: T;
+}
+/**
+ * Result of creating a relationship
+ * As documented in relationships.md
+ */
+export interface ICreateRelationshipResult<T = RelationshipProperties> {
+    /** The created relationship */
+    relationship: IRelationship<T>;
+    /** Always true for create */
+    created: boolean;
+}
+/**
+ * Options for finding relationships
+ * As documented in relationships.md
+ */
+export interface IFindRelationshipsOptions {
+    /** Relationship type(s) to filter by */
+    type?: string | string[];
+    /** Relationship types to filter by (alias for type) */
+    types?: string[];
+    /** Filter by source node ID */
+    startNodeId?: string | number;
+    /** Filter by target node ID */
+    endNodeId?: string | number;
+    /** Filter conditions on properties */
+    where?: IGraphWhereClause;
+    /** Maximum number of results */
+    limit?: number;
+    /** Number of results to skip */
+    offset?: number;
+    /** Number of results to skip (alias for offset) */
+    skip?: number;
+}
+/**
+ * Result of finding relationships
+ * As documented in relationships.md
+ */
+export interface IFindRelationshipsResult<T = RelationshipProperties> {
+    /** Array of matching relationships */
+    relationships: IRelationship<T>[];
+    /** Total count (for pagination) */
+    count?: number;
+    /** Total count (alias for count) */
+    total?: number;
+}
+/**
+ * Options for updating a relationship
+ * As documented in relationships.md
+ */
+export interface IUpdateRelationshipOptions<T = RelationshipProperties> {
+    /** Relationship ID to update */
+    id?: string | number;
+    /** Relationship type to filter by (for batch update) */
+    type?: string;
+    /** Filter conditions (for batch update) */
+    where?: IGraphWhereClause;
+    /** Properties to update */
+    properties: Partial<T> | IRelationshipPropertyUpdate;
+}
+/**
+ * Property update operations
+ * As documented in relationships.md
+ */
+export interface IRelationshipPropertyUpdate {
+    [key: string]: any | {
+        $INCREMENT: number;
+    } | {
+        $SET: any;
+    } | {
+        $UNSET: boolean;
+    };
+}
+/**
+ * Result of updating a relationship
+ * As documented in relationships.md
+ */
+export interface IUpdateRelationshipResult<T = RelationshipProperties> {
+    /** Updated relationship (if single update) */
+    relationship?: IRelationship<T>;
+    /** Updated relationships (if batch update) */
+    relationships?: IRelationship<T>[];
+    /** Number of relationships updated */
+    updatedCount?: number;
+    /** Whether the relationship was updated */
+    updated?: boolean;
+}
+/**
+ * Options for deleting a relationship
+ * As documented in relationships.md
+ */
+export interface IDeleteRelationshipOptions {
+    /** Relationship ID to delete */
+    id?: string | number;
+    /** Relationship type to filter by (for batch delete) */
+    type?: string;
+    /** Filter by source node ID */
+    startNodeId?: string | number;
+    /** Filter by target node ID */
+    endNodeId?: string | number;
+    /** Filter conditions (for batch delete) */
+    where?: IGraphWhereClause;
+}
+/**
+ * Result of deleting a relationship
+ * As documented in relationships.md
+ */
+export interface IDeleteRelationshipResult {
+    /** Whether deletion succeeded */
+    deleted: boolean;
+    /** Number of relationships deleted */
+    deletedCount?: number;
+    /** ID of deleted relationship */
+    id?: string | number;
+}
+/**
+ * Options for merge (upsert) relationship operation
+ * As documented in relationships.md
+ */
+export interface IMergeRelationshipOptions<T = RelationshipProperties> {
+    /** Relationship type */
+    type: string;
+    /** Source node ID */
+    startNodeId: string | number;
+    /** Target node ID */
+    endNodeId: string | number;
+    /** Properties to match on */
+    matchProperties?: Partial<T>;
+    /** Properties to set if relationship is created */
+    onCreate?: Partial<T>;
+    /** Properties to set if relationship already exists */
+    onMatch?: Partial<T> | IRelationshipPropertyUpdate;
+}
+/**
+ * Result of merge relationship operation
+ * As documented in relationships.md
+ */
+export interface IMergeRelationshipResult<T = RelationshipProperties> {
+    /** The resulting relationship */
+    relationship: IRelationship<T>;
+    /** true if created, false if matched */
+    created: boolean;
+    /** Whether the merge operation completed */
+    merged?: boolean;
+}
+/**
+ * Relationship filter for traversals
+ */
+export interface IRelationshipFilter {
+    /** Types to filter by */
+    types?: string[];
+    /** Property filter conditions */
+    where?: IGraphWhereClause;
+}
+/**
+ * Options for creating relationship index
+ * As documented in relationships.md
+ */
+export interface ICreateRelationshipIndexOptions {
+    /** Index name */
+    name: string;
+    /** Relationship type */
+    type: string;
+    /** Properties to index */
+    properties: string[];
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Graph Relationship Interfaces
+ *
+ * Types for relationship CRUD operations
+ * Based on Ductape Graph API documentation (relationships.md, overview.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=relationship.interface.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relationship.interface.js","sourceRoot":"","sources":["../../../src/graph/types/relationship.interface.ts"],"names":[],"mappings":";AAAA;;;;;GAKG"}

package/dist/graph/types/schema.interface.d.ts

@@ -0,0 +1,295 @@
+/**
+ * Graph Schema Interfaces
+ *
+ * Types for schema management (indexes, constraints)
+ * Based on Ductape Graph API documentation (overview.md)
+ */
+import { NodeConstraintType, NodeIndexType } from './enums';
+/**
+ * Options for creating a node index
+ * As documented in overview.md
+ */
+export interface ICreateNodeIndexOptions {
+    /** Index name */
+    name: string;
+    /** Node label to index */
+    label: string;
+    /** Properties to include in the index */
+    properties: string[];
+    /** Whether the index should enforce uniqueness */
+    unique?: boolean;
+    /** Index type */
+    type?: NodeIndexType | string;
+    /** Additional index options */
+    options?: {
+        sparse?: boolean;
+        unique?: boolean;
+    };
+}
+/**
+ * Options for creating a node constraint
+ * As documented in overview.md
+ */
+export interface ICreateNodeConstraintOptions {
+    /** Constraint name */
+    name: string;
+    /** Node label */
+    label: string;
+    /** Property to constrain */
+    property?: string;
+    /** Properties to constrain (for multi-property constraints) */
+    properties?: string[];
+    /** Constraint type: UNIQUE, EXISTS, NODE_KEY */
+    type: NodeConstraintType | 'UNIQUE' | 'EXISTS' | 'NODE_KEY';
+}
+/**
+ * Index information
+ */
+export interface IGraphIndex {
+    /** Index name */
+    name: string;
+    /** Label (for node indexes) or type (for relationship indexes) */
+    labelOrType: string;
+    /** Indexed properties */
+    properties: string[];
+    /** Whether unique */
+    unique: boolean;
+    /** Index type */
+    type: string;
+    /** Index state */
+    state?: string;
+}
+/**
+ * Constraint information
+ */
+export interface IGraphConstraint {
+    /** Constraint name */
+    name: string;
+    /** Label */
+    label: string;
+    /** Constrained property */
+    property: string;
+    /** Constraint type */
+    type: string;
+}
+/**
+ * Result of listing indexes
+ */
+export interface IListIndexesResult {
+    /** All indexes */
+    indexes: IGraphIndex[];
+}
+/**
+ * Result of listing constraints
+ */
+export interface IListConstraintsResult {
+    /** All constraints */
+    constraints: IGraphConstraint[];
+}
+/**
+ * Result of creating an index
+ */
+export interface ICreateIndexResult {
+    /** Whether index was created */
+    created: boolean;
+    /** Index name */
+    name: string;
+}
+/**
+ * Result of creating a constraint
+ */
+export interface ICreateConstraintResult {
+    /** Whether constraint was created */
+    created: boolean;
+    /** Constraint name */
+    name: string;
+}
+/**
+ * Result of dropping an index
+ */
+export interface IDropIndexResult {
+    /** Whether index was dropped */
+    dropped: boolean;
+}
+/**
+ * Result of dropping a constraint
+ */
+export interface IDropConstraintResult {
+    /** Whether constraint was dropped */
+    dropped: boolean;
+}
+/**
+ * Property type for schema introspection
+ */
+export type GraphPropertyType = 'string' | 'number' | 'boolean' | 'date' | 'datetime' | 'array' | 'point' | 'object' | 'unknown';
+/**
+ * Property definition for a label
+ */
+export interface IGraphLabelProperty {
+    /** Property name */
+    name: string;
+    /** Property type */
+    type: GraphPropertyType;
+    /** Whether property exists on all nodes with this label */
+    required?: boolean;
+}
+/**
+ * Label definition with schema information
+ */
+export interface IGraphLabel {
+    /** Label name */
+    name: string;
+    /** Number of nodes with this label */
+    count: number;
+    /** Properties found on nodes with this label */
+    properties: IGraphLabelProperty[];
+    /** Display color (optional, for UI purposes) */
+    color?: string;
+}
+/**
+ * Result of listing labels
+ */
+export interface IListLabelsResult {
+    /** All node labels */
+    labels: IGraphLabel[];
+}
+/**
+ * Relationship type definition with schema information
+ */
+export interface IGraphRelationshipType {
+    /** Relationship type name */
+    type: string;
+    /** Number of relationships of this type */
+    count: number;
+    /** Source node label(s) commonly used */
+    fromLabels?: string[];
+    /** Target node label(s) commonly used */
+    toLabels?: string[];
+    /** Properties found on relationships of this type */
+    properties?: IGraphLabelProperty[];
+}
+/**
+ * Result of listing relationship types
+ */
+export interface IListRelationshipTypesResult {
+    /** All relationship types */
+    types: IGraphRelationshipType[];
+}
+/**
+ * Parameter types for graph actions
+ */
+export type GraphActionParameterType = 'string' | 'number' | 'boolean' | 'array' | 'object';
+/**
+ * Parameter definition for a graph action
+ */
+export interface IGraphActionParameter {
+    /** Parameter name (used as placeholder {{name}}) */
+    name: string;
+    /** JSON path to the value in the query object */
+    path: string;
+    /** Default value for the parameter */
+    defaultValue: any;
+    /** Parameter type */
+    type: GraphActionParameterType;
+    /** Optional description */
+    description?: string;
+    /** Whether the parameter is required */
+    required?: boolean;
+}
+/**
+ * Graph action definition
+ * Represents a saved parameterized query that can be executed with different parameter values
+ */
+export interface IGraphAction {
+    /** Unique identifier */
+    id: string;
+    /** Unique tag (URL-safe slug) */
+    tag: string;
+    /** Display name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Operation type (e.g., findNodes, traverse, executeRaw) */
+    operation: string;
+    /** Query object with parameter placeholders */
+    query: Record<string, any>;
+    /** Parameter definitions */
+    parameters: IGraphActionParameter[];
+    /** ISO timestamp when action was created */
+    createdAt: string;
+    /** ISO timestamp when action was last updated */
+    updatedAt?: string;
+    /** Graph tag this action belongs to */
+    graphTag?: string;
+}
+/**
+ * Options for creating a graph action
+ */
+export interface ICreateGraphActionOptions {
+    /** Display name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Operation type */
+    operation: string;
+    /** Query object with parameter placeholders */
+    query: Record<string, any>;
+    /** Parameter definitions */
+    parameters: IGraphActionParameter[];
+    /** Graph tag (optional, defaults to current connected graph) */
+    graphTag?: string;
+}
+/**
+ * Options for updating a graph action
+ */
+export interface IUpdateGraphActionOptions {
+    /** Display name */
+    name?: string;
+    /** Optional description */
+    description?: string;
+    /** Query object with parameter placeholders */
+    query?: Record<string, any>;
+    /** Parameter definitions */
+    parameters?: IGraphActionParameter[];
+}
+/**
+ * Options for executing a graph action
+ */
+export interface IExecuteGraphActionOptions {
+    /** Product tag */
+    product: string;
+    /** Environment slug */
+    env: string;
+    /** Graph tag */
+    graph: string;
+    /** Action tag */
+    action: string;
+    /** Parameter values to substitute */
+    input?: Record<string, any>;
+    /** Session token in format: session_tag:jwt_token */
+    session?: string;
+    /** Cache tag for result caching */
+    cache?: string;
+}
+/**
+ * Result of executing a graph action
+ */
+export interface IExecuteGraphActionResult<T = any> {
+    /** Whether execution was successful */
+    success: boolean;
+    /** Execution time in milliseconds */
+    executionTime: number;
+    /** Result data */
+    data: T[];
+    /** Row count */
+    count: number;
+    /** Error message if failed */
+    error?: string;
+}
+/**
+ * Result of listing graph actions
+ */
+export interface IListGraphActionsResult {
+    /** All actions for the graph */
+    actions: IGraphAction[];
+}

package/dist/graph/types/schema.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Graph Schema Interfaces
+ *
+ * Types for schema management (indexes, constraints)
+ * Based on Ductape Graph API documentation (overview.md)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.interface.js.map