mftsccs-node 0.2.23 → 0.2.24

package/dist/types/Api/GetConnections/GetConnectionsBetweenApi.d.ts

@@ -0,0 +1,8 @@
+import { FetchConnection } from "../../DataStructures/FetchConnection";
+/**
+ * Fetches connection IDs matching one or more connection queries.
+ *
+ * Each item is resolved independently by the backend and returned with
+ * connectionIds populated.
+ */
+export declare function GetConnectionsBetweenApi(fetchConnections: FetchConnection[]): Promise<FetchConnection[]>;

package/dist/types/Api/GetReservedConnectionIds.d.ts

@@ -34,4 +34,4 @@
  * @see ReservedConnectionIds for the storage data structure
  * @see GetReservedIds for fetching regular concept IDs
  */
-export declare function GetReservedConnectionIds(): Promise<void>;
+export declare function GetReservedConnectionIds(count?: number): Promise<void>;

package/dist/types/DataStructures/BaseUrl.d.ts

@@ -64,6 +64,11 @@ export declare class BaseUrl {
      * @returns {string} The user connections retrieval API endpoint
      */
     static GetAllConnectionsOfUserUrl(): string;
+    /**
+     * Returns the URL for retrieving connection IDs matching connection filters.
+     * @returns {string} The connection filtering API endpoint
+     */
+    static GetConnectionsBetweenUrl(): string;
     /**
      * Returns the URL for retrieving all connections of a composition.
      * @returns {string} The composition connections retrieval API endpoint

package/dist/types/DataStructures/FetchConnection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Request/response shape for POST /api/get-connection-between.
+ *
+ * Use only the fields relevant to the query and leave the rest at their
+ * zero/empty defaults. The backend resolves typeId from type when typeId is 0.
+ */
+export interface FetchConnection {
+    ofTheConceptId: number;
+    toTheConceptId: number;
+    typeId: number;
+    type: string;
+    oldType: string;
+    reverse: boolean;
+    isComposition: boolean;
+    connectionIds: number[];
+}
+export type FetchConnectionQuery = Omit<FetchConnection, 'connectionIds'>;
+/**
+ * Builds a complete FetchConnection request object from a partial query.
+ */
+export declare function buildFetchConnection(query: Partial<FetchConnectionQuery>): FetchConnection;

package/dist/types/DataStructures/ReservedIds.d.ts

@@ -77,21 +77,13 @@ export declare class ReservedIds {
 export declare class ReservedConnectionIds {
     /** Pool of reserved connection IDs */
     static connectionIds: number[];
+    private static pendingFetch;
     /**
      * Gets the next available reserved connection ID from the pool.
-     * Automatically refills the pool if it has fewer than 10 IDs.
+     * Triggers a background refill when the pool is low, and waits for a fetch
+     * if the pool is completely empty. Only one fetch is in-flight at a time.
      *
      * @returns {Promise<number>} A unique reserved connection ID
-     *
-     * @example
-     * ```typescript
-     * const id = await ReservedConnectionIds.getId();
-     * const connection = new Connection(id, ...);
-     * ```
-     *
-     * @remarks
-     * Uses FIFO (first in, first out) to retrieve IDs.
-     * Triggers a backend call to GetReservedConnectionIds when pool is low.
      */
     static getId(): Promise<number>;
     /**
@@ -99,13 +91,15 @@ export declare class ReservedConnectionIds {
      *
      * @param {number} id - The ID to add to the pool
      *
-     * @example
-     * ```typescript
-     * ReservedConnectionIds.AddId(456);
-     * ```
-     *
      * @remarks
      * Prevents duplicate IDs from being added to the pool.
      */
     static AddId(id: number): void;
+    /**
+     * Pre-fills the pool with at least `needed` IDs in a single API call.
+     * Call this before a parallel batch so getId() never has to wait mid-flight.
+     *
+     * @param {number} needed - Total IDs required for the upcoming batch
+     */
+    static warmUp(needed: number): Promise<void>;
 }

package/dist/types/DataStructures/Transaction/Transaction.d.ts

@@ -4,6 +4,7 @@
  */
 import { Concept } from "../Concept";
 import { Connection } from "../Connection";
+import { FetchConnectionQuery } from "../FetchConnection";
 /**
  * Manages transactional operations for concepts and connections.
  * This class provides ACID-like transaction capabilities for creating and managing
@@ -69,6 +70,14 @@ export declare class Transaction {
      * @default true
      */
     protected success: boolean;
+    /**
+     * Connection IDs queued for deletion when the transaction commits.
+     * Rollback clears this list without touching the backend.
+     *
+     * @protected
+     * @type {number[]}
+     */
+    protected pendingConnectionDeletions: number[];
     /**
      * Creates a new Transaction instance.
      * Generates a unique transaction ID for tracking purposes.
@@ -154,6 +163,20 @@ export declare class Transaction {
      * ```
      */
     commitTransaction(): Promise<void>;
+    /**
+     * Queues connections matching one query for deletion on commit.
+     *
+     * Nothing is deleted until commitTransaction() is called. Calling
+     * rollbackTransaction() discards the queued IDs.
+     */
+    DeleteConnectionsBetween(query: Partial<FetchConnectionQuery>): Promise<number[]>;
+    /**
+     * Queues connections matching multiple queries for deletion on commit.
+     *
+     * The queries are resolved in one API call, then their connection IDs are
+     * merged into this transaction's pending deletion queue.
+     */
+    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[]): Promise<number[]>;
     /**
    * Creates a new instance concept within the transaction.
    * The concept represents a data instance of a specified type with associated metadata.

package/dist/types/DataStructures/User/UserBinaryTree.d.ts

@@ -1,132 +1,14 @@
-/**
- * @fileoverview Binary tree for managing user-specific concepts and connections.
- * This module provides a composite-key based tree for efficient user and session-based data storage.
- * @module DataStructures/User/UserBinaryTree
- */
 import { LConcept } from "../../DataStructures/Local/LConcept";
 import { UserNode } from "./UserNode";
 import { LConnection } from "../Local/LConnection";
-/**
- * Binary tree data structure for managing user-specific data with composite keys.
- *
- * @remarks
- * This class implements an AVL tree that uses composite keys (userId + sessionId + randomizer)
- * to organize user-specific concepts and connections. The composite key enables efficient
- * organization and retrieval of data by user, session, and application context.
- *
- * @example
- * ```typescript
- * const concept = new LConcept(123, "example", 5);
- * UserBinaryTree.addConceptToTree(concept, 42, 999);
- * const node = await UserBinaryTree.getNodeFromTree(42, 999, 123);
- * ```
- */
 export declare class UserBinaryTree {
-    /**
-     * The root node of the user data binary tree.
-     * Null if the tree is empty.
-     */
-    static root: UserNode | null;
-    /**
-     * Creates a composite key from user ID, session ID, and randomizer.
-     *
-     * @param userId - The user ID
-     * @param sessionId - The session ID
-     * @param randomizer - Additional identifier (defaults to 999)
-     * @returns A 12-character hexadecimal composite key
-     *
-     * @remarks
-     * The composite key is formed by concatenating three 4-digit hexadecimal values:
-     * userHex (4 chars) + sessionHex (4 chars) + randomizerHex (4 chars) = 12 chars total.
-     * This enables unique identification of data across users, sessions, and applications.
-     *
-     * @example
-     * ```typescript
-     * const key = UserBinaryTree.compositeKey(42, 999, 123);
-     * // Returns something like "002A03E7007B"
-     * ```
-     */
+    static nodeMap: Map<string, UserNode>;
     static compositeKey(userId: number, sessionId: number, randomizer?: number): string;
-    /**
-     * Adds a user node to the binary tree.
-     *
-     * @param node - The UserNode to be added to the tree
-     *
-     * @remarks
-     * If the tree is empty, the provided node becomes the root.
-     * Otherwise, the node is inserted using the AVL tree balancing algorithm.
-     */
-    static addNodeToTree(node: UserNode): UserNode | undefined;
-    /**
-     * Waits for user data to be loaded into the tree.
-     *
-     * @returns A promise that resolves with "done" when data is loaded, or rejects with "not" after 25 seconds
-     */
     static waitForDataToLoad(): Promise<unknown>;
-    /**
-     * Periodically checks if user data has been loaded.
-     *
-     * @param resolve - The promise resolve function to call when data is loaded
-     */
     static checkFlag(resolve: any): any;
-    /**
-     * Creates a node from a concept and adds it to the user tree.
-     *
-     * @param concept - The LConcept object to be added
-     * @param userId - The user ID
-     * @param sessionId - The session ID (defaults to 999)
-     *
-     * @remarks
-     * Uses the concept's applicationId as the randomizer in the composite key.
-     */
     static addConceptToTree(concept: LConcept, userId: number, sessionId?: number): void;
-    /**
-     * Creates a node from a connection and adds it to the user tree.
-     *
-     * @param connection - The LConnection object to be added
-     * @param userId - The user ID
-     * @param sessionId - The session ID (defaults to 999)
-     *
-     * @remarks
-     * Uses the connection's applicationId as the randomizer in the composite key.
-     */
     static addConnectionToTree(connection: LConnection, userId: number, sessionId?: number): void;
-    /**
-     * Retrieves a node from the tree using composite key components.
-     *
-     * @param userId - The user ID
-     * @param sessionId - The session ID
-     * @param randomizer - Additional identifier (defaults to 999)
-     * @returns The UserNode if found, null otherwise
-     *
-     * @remarks
-     * Constructs a composite key from the parameters and performs a binary search.
-     */
     static getNodeFromTree(userId: number, sessionId: number, randomizer?: number): Promise<UserNode | null>;
-    /**
-     * Removes a node from the tree using composite key components.
-     *
-     * @param userId - The user ID
-     * @param sessionId - The session ID (defaults to 999)
-     * @param randomizer - Additional identifier (defaults to 999)
-     *
-     * @remarks
-     * Constructs a composite key and removes the matching node while maintaining AVL balance.
-     */
     static removeNodeFromTree(userId: number, sessionId?: number, randomizer?: number): Promise<void>;
-    /**
-     * Counts the total number of nodes in the tree.
-     *
-     * @returns The total number of user nodes in the tree
-     *
-     * @remarks
-     * Recursively traverses the entire tree to count all nodes. Returns 0 if the tree is empty.
-     *
-     * @example
-     * ```typescript
-     * const count = UserBinaryTree.countNumberOfNodes();
-     * console.log(`Tree contains ${count} user data nodes`);
-     * ```
-     */
     static countNumberOfNodes(): number;
 }

package/dist/types/DataStructures/User/UserNode.d.ts

@@ -1,150 +1,8 @@
-/**
- * @fileoverview Node implementation for the UserBinaryTree.
- * This module provides the UserNode class for storing user-specific concepts and connections.
- * @module DataStructures/User/UserNode
- */
 import { LConcept } from "../Local/LConcept";
 import { LConnection } from "../Local/LConnection";
-/**
- * Represents a node in the user binary tree that stores both concepts and connections.
- *
- * @remarks
- * UserNode implements an AVL tree node that can store multiple concepts and connections
- * for a given composite key (userId + sessionId + randomizer). This allows efficient
- * storage and retrieval of all user data associated with a specific key combination.
- *
- * @example
- * ```typescript
- * const concept = new LConcept(123, "example", 5);
- * const connection = new LConnection(456, 1, 2, 3, 4, 5);
- * const node = new UserNode("compositeKey", concept, connection, null, null);
- * ```
- */
 export declare class UserNode {
-    /**
-     * The composite key used for tree ordering.
-     * Typically a hexadecimal string combining userId, sessionId, and randomizer.
-     */
-    key: any;
-    /**
-     * Array of connections stored in this node.
-     * Multiple connections can be associated with the same key.
-     */
-    connectionValue: LConnection[];
-    /**
-     * Array of concepts stored in this node.
-     * Multiple concepts can be associated with the same key.
-     */
-    value: LConcept[];
-    /**
-     * Reference to the left child node.
-     */
-    leftNode: UserNode | null;
-    /**
-     * Reference to the right child node.
-     */
-    rightNode: UserNode | null;
-    /**
-     * The height of this node in the tree.
-     * Used for AVL tree balancing calculations.
-     */
-    height: number;
-    /**
-     * Creates a new UserNode.
-     *
-     * @param key - The composite key for tree ordering
-     * @param value - The LConcept to store (added if ID > 0)
-     * @param connectionValue - The LConnection to store (added if ID > 0)
-     * @param leftNode - The left child node (or null)
-     * @param rightNode - The right child node (or null)
-     *
-     * @remarks
-     * Only adds concepts and connections with valid (> 0) IDs to their respective arrays.
-     *
-     * @example
-     * ```typescript
-     * const node = new UserNode("compositeKey", concept, connection, null, null);
-     * ```
-     */
-    constructor(key: any, value: LConcept, connectionValue: LConnection, leftNode: UserNode | null, rightNode: UserNode | null);
-    /**
-     * Adds a new node to the tree with AVL balancing.
-     *
-     * @param passedNode - The node to be added
-     * @param node - The current node being evaluated
-     * @param height - The height of the current node
-     * @returns The root node after insertion and balancing
-     *
-     * @remarks
-     * Implements AVL tree insertion. When a node with the same key exists,
-     * the new node's concepts and connections are added to the existing node's arrays.
-     */
-    addNode(passedNode: UserNode, node: UserNode | null, height: number): UserNode | null;
-    /**
-     * Performs a right rotation on the given node for AVL balancing.
-     *
-     * @param y - The node to rotate right
-     * @returns The new root node after rotation
-     */
-    rightRotate(y: UserNode | null): UserNode | null;
-    /**
-     * Performs a left rotation on the given node for AVL balancing.
-     *
-     * @param x - The node to rotate left
-     * @returns The new root node after rotation
-     */
-    leftRotate(x: UserNode | null): UserNode | null;
-    /**
-     * Gets the height of a node.
-     *
-     * @param node - The node to get the height from
-     * @returns The height of the node, or 0 if null
-     */
-    getHeight(node: UserNode | null): number;
-    /**
-     * Calculates the balance factor of a node.
-     *
-     * @param N - The node to calculate the balance factor for
-     * @returns The balance factor (difference between left and right heights)
-     */
-    getBalanceFactor(N: UserNode | null): number;
-    /**
-     * Retrieves a node from the tree by its composite key.
-     *
-     * @param id - The composite key string to search for
-     * @param node - The current node being evaluated
-     * @returns The matching UserNode if found, null otherwise
-     */
-    getFromNode(id: string, node: UserNode | null): UserNode | null;
-    /**
-     * Removes a node from the tree by its composite key.
-     *
-     * @param passedNode - The current node being evaluated
-     * @param id - The composite key string to remove
-     * @returns The root node after removal
-     *
-     * @remarks
-     * Implements standard BST deletion with in-order successor replacement.
-     */
-    removeNode(passedNode: UserNode | null, id: string): UserNode | null;
-    /**
-     * Counts all nodes below and including the given node.
-     *
-     * @param root - The root node to start counting from
-     * @returns The total number of nodes in the subtree
-     *
-     * @remarks
-     * Recursively traverses the entire subtree to count all nodes.
-     */
-    countNodeBelow(root: UserNode | null): number;
-    /**
-     * Finds the in-order successor of a node.
-     *
-     * @param root - The node to find the successor from
-     * @returns The in-order successor node (leftmost node in right subtree)
-     *
-     * @remarks
-     * Used during node deletion to find the replacement node.
-     */
-    inOrderSuccessor(root: UserNode): UserNode;
+    key: string;
+    value: Map<number, LConcept>;
+    connectionValue: Map<number, LConnection>;
+    constructor(key: string, value: LConcept, connectionValue: LConnection);
 }

package/dist/types/app.d.ts

@@ -31,7 +31,7 @@ export { MakeTheTypeConcept } from './Services/MakeTheTypeConcept';
 export { MakeTheTypeConceptApi } from './Api/MakeTheTypeConceptApi';
 export { GetLinkerConnectionFromConcepts, GetLinkerConnectionToConcepts } from './Services/GetLinkerConnectionFromConcept';
 export { DeleteConceptById } from './Services/DeleteConcept';
-export { DeleteConnectionById } from './Services/DeleteConnection';
+export { DeleteConnectionById, DeleteConnectionByIdBulk } from './Services/DeleteConnection';
 export { TrashTheConcept } from './Api/Delete/DeleteConceptInBackend';
 export { GetConnectionById } from './Services/GetConnections';
 export { MakeTheTimestamp } from './Services/MakeTheTimestamp';
@@ -99,10 +99,13 @@ export { TokenStorage } from './DataStructures/Security/TokenStorage';
 export { SchemaQueryListener } from './WrapperFunctions/SchemaQueryObservable';
 export { FreeschemaQuery } from './DataStructures/Search/FreeschemaQuery';
 export { GiveConnection, GetAllTheConnectionsByTypeAndOfTheConcept } from './Services/Delete/GetAllConnectionByType';
+export { GetConnectionsBetweenApi } from './Api/GetConnections/GetConnectionsBetweenApi';
+export { FetchConnection, FetchConnectionQuery, buildFetchConnection } from './DataStructures/FetchConnection';
 export { DATAID, NORMAL, JUSTDATA, ALLID, DATAIDDATE, RAW, LISTNORMAL, DATAV2 } from './Constants/FormatConstants';
 export { AccessControlService } from './Services/AccessControl/AccessControlService';
 export { PermissionSet } from './Services/AccessControl/PermissionSet';
-export { Transaction } from './DataStructures/Transaction/Transaction';
+export { Transaction, InnerActions } from './DataStructures/Transaction/Transaction';
+export { ReservedIds, ReservedConnectionIds } from './DataStructures/ReservedIds';
 /**
  * Updates the bearer access token used for authenticating API requests to the backend.
  * This token is stored globally and used by all API calls that require authentication.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mftsccs-node",
-  "version": "0.2.23",
+  "version": "0.2.24",
   "environment": "production",
   "description": "Full Pack of concept and connection system",
   "main": "dist/bundle.js",