mftsccs-browser 2.2.20-beta → 2.2.22-beta

package/dist/types/Services/AccessControl/AccessControlService.d.ts

@@ -0,0 +1,267 @@
+import { PermissionSet } from "./PermissionSet";
+export declare class AccessControlService {
+    private static accessCache;
+    private static baseUrl;
+    private static initialize;
+    /**
+     * Checks if a user or entity has the specified access for a single concept.
+     * @param userId - The user's ID.
+     * @param access - The required PermissionSet.
+     * @param conceptId - The concept ID to check.
+     * @param entityId - Optional entity ID (defaults to userId).
+     * @returns Promise<boolean> - True if access is granted, false otherwise.
+     */
+    static checkAccessOfConcept(userId: number, access: PermissionSet, conceptId: number, entityId?: number): Promise<boolean>;
+    /**
+     * Checks if a user or entity has the specified access for all concepts in a list.
+     * @param userId - The user's ID.
+     * @param access - The required PermissionSet.
+     * @param conceptIdList - Array of concept IDs to check.
+     * @param entityId - Optional entity ID (defaults to userId).
+     * @returns Promise<boolean> - True if access is granted for all, false otherwise.
+     */
+    static checkAccessOfConceptList(userId: number, access: PermissionSet, conceptIdList: number[], entityId?: number): Promise<boolean>;
+    /**
+     * Filters a list of concept IDs, returning only those for which the user or entity has the specified access.
+     * @param userId - The user's ID.
+     * @param access - The required PermissionSet.
+     * @param conceptIdList - Array of concept IDs to filter.
+     * @param entityId - Optional entity ID (defaults to userId).
+     * @returns Promise<number[]> - Array of concept IDs with access.
+     */
+    static filterConceptListByAccess(userId: number, access: PermissionSet, conceptIdList: number[], entityId?: number): Promise<number[]>;
+    /**
+     * Gets the entity ID for a given user ID.
+     * @param userId - The user's ID.
+     * @returns number - The entity ID (default: userId).
+     */
+    private static getEntityIdConceptByUserId;
+    /**
+     * Assigns access to a specific entity for a concept.
+     * @param request - Object containing conceptId, access, entityId, makePublic.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessToEntity(request: {
+        conceptId: number;
+        access: string;
+        entityId: number;
+        makePublic: boolean;
+    }): Promise<any>;
+    /**
+     * Assigns public access to a concept or list of concepts.
+     * @param request - Object containing conceptId, accessList, connectionTypeList, nestedAccessLevel, conceptIdList.
+     * @returns Promise<any> - API response.
+     */
+    static assignPublicAccess(request: {
+        conceptId: number;
+        accessList: string[];
+        connectionTypeList?: string[];
+        nestedAccessLevel?: number;
+        conceptIdList?: number[];
+    }): Promise<any>;
+    /**
+     * Assigns public access to multiple concepts in bulk.
+     * @param request - Object containing conceptIdList, accessList, connectionTypeList, nestedAccessLevel, conceptId.
+     * @returns Promise<any> - API response.
+     */
+    static assignPublicAccessBlukConcept(request: {
+        conceptIdList: number[];
+        accessList: string[];
+        connectionTypeList?: string[];
+        nestedAccessLevel?: number;
+        conceptId?: number;
+    }): Promise<any>;
+    /**
+     * Assigns access to multiple entities and concepts in bulk.
+     * @param request - Object containing conceptId, conceptIdList, entityIdList, accessList, connectionTypeList, nestedAccessLevel.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessToEntityBulk(request: {
+        conceptId: number;
+        conceptIdList?: number[];
+        entityIdList: number[];
+        accessList: string[];
+        connectionTypeList?: string[];
+        nestedAccessLevel?: number;
+    }): Promise<any>;
+    /**
+     * Assigns access to a user for a concept.
+     * @param request - Object containing conceptId, access, userId, makePublic.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessByUser(request: {
+        conceptId: number;
+        access: string;
+        userId: number;
+        makePublic: boolean;
+    }): Promise<any>;
+    /**
+     * Revokes access for an entity from a concept.
+     * @param params - Object containing conceptId, access, entityId.
+     * @returns Promise<any> - API response.
+     */
+    static revokeAccess(params: {
+        conceptId: number;
+        access: string;
+        entityId: number;
+    }): Promise<any>;
+    /**
+     * Revokes access for multiple entities in bulk.
+     * @param request - Object containing conceptId, entityIdList, accessList.
+     * @returns Promise<any> - API response.
+     */
+    static revokeAccessBulk(request: {
+        conceptId: number;
+        entityIdList: number[];
+        accessList: string[];
+    }): Promise<any>;
+    /**
+     * Gets the access list for a concept and user.
+     * @param conceptId - The concept ID.
+     * @param userId - The user ID.
+     * @returns Promise<any> - API response.
+     */
+    static getAccessList(conceptId: number, userId: number): Promise<any>;
+    /**
+     * Gets the public access list for a list of concept IDs.
+     * @param conceptIdList - Array of concept IDs.
+     * @returns Promise<any> - API response.
+     */
+    static getPublicAccessList(conceptIdList: number[]): Promise<any>;
+    /**
+     * Revokes public access for a concept.
+     * @param request - Object containing conceptId, accessList.
+     * @returns Promise<any> - API response.
+     */
+    static revokePublicAccess(request: {
+        conceptId: number;
+        accessList: string[];
+    }): Promise<any>;
+    /**
+     * Checks if an entity has a specific permission for a concept.
+     * @param params - Object containing conceptId, permission, entityId.
+     * @returns Promise<any> - API response.
+     */
+    static checkAccess(params: {
+        conceptId: number;
+        permission: string;
+        entityId: number;
+    }): Promise<any>;
+    /**
+     * Checks if a user has a specific access for a concept.
+     * @param request - Object containing conceptId, access, userId.
+     * @returns Promise<any> - API response.
+     */
+    static checkAccessByUser(request: {
+        conceptId: number;
+        access: string;
+        userId: number;
+    }): Promise<any>;
+    /**
+     * Filters concepts by access for a user.
+     * @param request - Object containing userId, access, conceptIdList, connectionIdList.
+     * @returns Promise<any> - API response.
+     */
+    static filterConceptsByAccess(request: {
+        userId: number;
+        access: string;
+        conceptIdList?: number[];
+        connectionIdList?: number[];
+    }): Promise<any>;
+    /**
+     * Checks access for a user on multiple concepts in bulk.
+     * @param request - Object containing userId, access, conceptIdList.
+     * @returns Promise<any> - API response.
+     */
+    static checkAccessOfConceptBulk(request: {
+        userId: number;
+        access: string;
+        conceptIdList: number[];
+    }): Promise<any>;
+    /**
+     * Gets entities with a specific access for a concept.
+     * @param conceptId - The concept ID.
+     * @param access - The access type.
+     * @returns Promise<any> - API response.
+     */
+    static getEntitiesByAccess(conceptId: number, access: string): Promise<any>;
+    /**
+     * Gets all entities with any access for a concept.
+     * @param conceptId - The concept ID.
+     * @returns Promise<any> - API response.
+     */
+    static getEntitiesWithAccess(conceptId: number): Promise<any>;
+    /**
+     * Gets access groups by entity.
+     * @param entityId - Optional entity ID.
+     * @returns Promise<any> - API response.
+     */
+    static getAccessGroupByEntity(entityId?: number): Promise<any>;
+    /**
+     * Gets access groups by user.
+     * @param userId - Optional user ID.
+     * @returns Promise<any> - API response.
+     */
+    static getAccessGroupByUser(userId?: number): Promise<any>;
+    /**
+     * Gets public access by access IDs.
+     * @param accessIdList - Array of access IDs.
+     * @returns Promise<any> - API response.
+     */
+    static getPublicAccessByAccessIds(accessIdList: number[]): Promise<any>;
+    /**
+     * Gets the full access mapping for public users.
+     * @returns Promise<any> - API response.
+     */
+    static getFullAccessMappingForPublic(): Promise<any>;
+    /**
+     * Assigns public access for all users.
+     * @returns Promise<any> - API response.
+     */
+    static assignPublicAccessForAllUser(): Promise<any>;
+    /**
+     * Assigns access by connection type for users.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessByConncetionTypeOfUser(): Promise<any>;
+    /**
+     * Sets access inheritance for a concept.
+     * @param request - Object containing mainConceptId, enable, connectionTypeId.
+     * @returns Promise<any> - API response.
+     */
+    static setAccessInheritance(request: {
+        mainConceptId: number;
+        enable: boolean;
+        connectionTypeId?: number;
+    }): Promise<any>;
+    /**
+     * Gets the status of access inheritance for a concept.
+     * @param mainConceptId - The main concept ID.
+     * @param connectionTypeId - The connection type ID (default: 999).
+     * @returns Promise<any> - API response.
+     */
+    static getAccessInheritanceStatus(mainConceptId: number, connectionTypeId?: number): Promise<any>;
+    /**
+     * Performs a GET request to the backend API.
+     * @param path - The API path.
+     * @param errorMsg - Error message to throw if request fails.
+     * @returns Promise<any> - API response.
+     */
+    private static _get;
+    /**
+     * Performs a POST request to the backend API.
+     * @param path - The API path.
+     * @param body - Request body.
+     * @param errorMsg - Error message to throw if request fails.
+     * @returns Promise<any> - API response.
+     */
+    private static _post;
+    /**
+     * Performs a DELETE request to the backend API.
+     * @param path - The API path.
+     * @param body - Optional request body.
+     * @param errorMsg - Error message to throw if request fails.
+     * @returns Promise<any> - API response.
+     */
+    private static _delete;
+}

package/dist/types/Services/AccessControl/PermissionSet.d.ts

@@ -0,0 +1,8 @@
+export declare enum PermissionSet {
+    None = 0,
+    Read = 1,
+    Write = 2,
+    Execute = 4,
+    Delete = 8
+}
+export declare function getPermissionSetFromStrings(permissions: string[]): PermissionSet;

package/dist/types/Services/CreateTheConcept.d.ts

@@ -1,4 +1,122 @@
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Creates a new concept and adds it to the sync queue for backend synchronization.
+ *
+ * This is the primary function for creating concepts in the system. The concept is:
+ * - Assigned a unique ID from the reserved ID pool
+ * - Marked as non-temporary (persisted)
+ * - Added to the SyncData queue for automatic backend synchronization
+ * - Cached locally in IndexedDB for offline access
+ *
+ * @param {string} referent - The character value (text/name) of the concept. This is the human-readable
+ *                           representation of the concept (e.g., "John Doe", "Project Alpha")
+ * @param {number} userId - The ID of the user creating this concept. Used for ownership and access control.
+ * @param {number} categoryId - The category classification ID. Used for further classification within a type
+ *                             (e.g., for TYPE_PERSON: 1=Employee, 2=Contractor, 3=Customer)
+ * @param {number} typeId - The type classification ID. Defines what kind of concept this is
+ *                         (e.g., 1=Person, 2=Organization, 3=Document)
+ * @param {number} referentId - Optional reference to another concept ID. Used for creating instances
+ *                             that reference a type concept. Can be 0 or null if not applicable.
+ * @param {number} accessId - Access control level for the concept. Determines who can view/edit
+ *                           (e.g., 1=Public, 2=Private, 3=Shared, 4=Admin)
+ * @param {string} typeCharacter - The string representation of the type name (e.g., "Person", "Document").
+ *                                Used for display and filtering purposes.
+ *
+ * @returns {Promise<Concept>} A promise that resolves to the newly created Concept object with all properties set.
+ *
+ * @example
+ * // Create a person concept
+ * const person = await CreateTheConcept(
+ *   "Alice Smith",  // name
+ *   101,           // userId
+ *   1,             // categoryId (Employee)
+ *   1,             // typeId (Person)
+ *   0,             // referentId (none)
+ *   2,             // accessId (Private)
+ *   "Person"       // typeCharacter
+ * );
+ * console.log(person.id); // 12345
+ *
+ * @see {@link CreateTheConceptTemporary} for creating non-persisted temporary concepts
+ * @see {@link CreateTheConceptImmediate} for creating concepts with immediate backend sync
+ */
 export default function CreateTheConcept(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+/**
+ * Creates a temporary concept that is NOT persisted to the database or synced to the backend.
+ *
+ * Use this function when you need a transient concept that exists only in memory during the
+ * current session. Temporary concepts are useful for:
+ * - UI state management
+ * - Draft content before finalization
+ * - Calculations or intermediate results
+ * - Testing without affecting the database
+ *
+ * Temporary concepts are marked with `isTemp = true` and will not be saved when the application
+ * closes or refreshes. They are NOT added to the SyncData queue.
+ *
+ * @param referent - The character value (text/name) of the concept
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The category classification ID
+ * @param typeId - The type classification ID
+ * @param referentId - Optional reference to another concept ID
+ * @param accessId - Access control level for the concept
+ * @param typeCharacter - The string representation of the type name
+ *
+ * @returns Promise resolving to the temporary Concept object
+ *
+ * @example
+ * // Create a temporary draft note
+ * const draftNote = await CreateTheConceptTemporary(
+ *   "Draft: Meeting Notes",
+ *   101,
+ *   1,
+ *   3,  // Document type
+ *   0,
+ *   2,
+ *   "Document"
+ * );
+ * console.log(draftNote.isTemp); // true
+ *
+ * @see {@link CreateTheConcept} for creating persistent concepts
+ */
 export declare function CreateTheConceptTemporary(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+/**
+ * Creates a concept and immediately sends it to the backend API, bypassing the sync queue.
+ *
+ * This function is useful when you need guaranteed immediate synchronization to the backend,
+ * such as for critical operations that must be persisted right away. Unlike the standard
+ * CreateTheConcept, this function:
+ * - Calls the backend API directly (CreateTheConceptApi)
+ * - Does NOT use the SyncData queue (bypasses batch synchronization)
+ * - Adds the concept to local ConceptsData immediately
+ * - Marks the concept as NOT new (isNew = false)
+ *
+ * Use this for time-sensitive operations where you cannot wait for the next sync cycle.
+ *
+ * @param referent - The character value (text/name) of the concept
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The category classification ID
+ * @param typeId - The type classification ID
+ * @param referentId - Optional reference to another concept ID (can be null)
+ * @param accessId - Access control level for the concept
+ * @param typeCharacter - The string representation of the type name
+ *
+ * @returns Promise resolving to the created Concept object
+ *
+ * @example
+ * // Create a critical log entry that must be saved immediately
+ * const logEntry = await CreateTheConceptImmediate(
+ *   "Critical Error: System Failure",
+ *   101,
+ *   5,  // Log category
+ *   7,  // Log type
+ *   null,
+ *   1,  // Public access
+ *   "LogEntry"
+ * );
+ * // Concept is immediately sent to backend
+ *
+ * @see {@link CreateTheConcept} for standard queued creation
+ * @see {@link CreateTheConceptApi} for the backend API call
+ */
 export declare function CreateTheConceptImmediate(referent: string, userId: number, categoryId: number, typeId: number, referentId: number | null, accessId: number, typeCharacter: string): Promise<Concept>;

package/dist/types/Services/CreateTheConnection.d.ts

@@ -1,10 +1,63 @@
 import { Connection } from "../DataStructures/Connection";
 /**
- * This function is used to create a connection that is internal(inside of a composition)
- * @param ofTheConceptId Start of the connection
- * @param userId user id fo the user creating the connection
- * @param toTheConceptId the end of the connection
- * @param typeId this is the type of the connection
- * @returns
+ * Creates a connection (relationship) between two concepts and adds it to the sync queue.
+ *
+ * This is the primary function for establishing relationships in the knowledge graph.
+ * Connections are directed edges that link two concepts together, representing relationships
+ * like "works at", "belongs to", "authored by", etc.
+ *
+ * **Connection Structure:**
+ * - FROM concept (ofTheConceptId) → TO concept (toTheConceptId)
+ * - The relationship is directional
+ * - Type ID classifies what kind of relationship it is
+ * - Order ID allows sorting when multiple connections of the same type exist
+ *
+ * **Important Behaviors:**
+ * - Connections are marked as temporary (isTemp = true) for internal compositions
+ * - Added to SyncData queue for backend synchronization
+ * - Assigned a random temporary ID until persisted
+ * - Self-connections (same from/to) are prevented (returns invalid connection)
+ * - Default access level is 4 (typically means "admin" or "restricted")
+ *
+ * @param ofTheConceptId - The source concept ID (start of the relationship).
+ *                        This is where the connection originates FROM.
+ * @param userId - The ID of the user creating this connection. Used for ownership and permissions.
+ * @param toTheConceptId - The target concept ID (end of the relationship).
+ *                        This is where the connection points TO.
+ * @param typeId - The type classification for this connection. Defines the nature of the relationship.
+ *                (e.g., 5="works_at", 6="manages", 7="member_of")
+ *
+ * @returns The created Connection object with all properties set, including a temporary ID
+ *
+ * @example
+ * // Create a "works at" relationship
+ * const connection = createTheConnection(
+ *   aliceId,      // Alice (person)
+ *   101,          // user creating this
+ *   companyId,    // Tech Corp (organization)
+ *   5             // "works at" connection type
+ * );
+ * // Result: Alice → works_at → Tech Corp
+ *
+ * @example
+ * // Create a hierarchical relationship
+ * const managerConnection = createTheConnection(
+ *   managerId,    // Manager concept
+ *   101,          // user
+ *   employeeId,   // Employee concept
+ *   6             // "manages" connection type
+ * );
+ * // Result: Manager → manages → Employee
+ *
+ * @example
+ * // Attempting self-connection (will return invalid connection)
+ * const selfConn = createTheConnection(123, 101, 123, 5);
+ * console.log(selfConn.ofTheConceptId); // 0 (invalid)
+ * console.log(selfConn.toTheConceptId); // 1 (invalid)
+ *
+ * @throws Errors are caught and logged via HandleInternalError but don't prevent return
+ *
+ * @see {@link CreateTheConnectionGeneral} for alternative connection creation
+ * @see {@link CreateTheConnectionApi} for direct backend API connection creation
  */
 export declare function createTheConnection(ofTheConceptId: number, userId: number, toTheConceptId: number, typeId: number): Connection;

package/dist/types/Services/Delete/DeleteConnectionByType.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param id the id of the concept whose connection needs to be returned
+ * @param linkers the connection types whose connection id need to be found
+ */
+export declare function DeleteConnectionByTypeBulk(id: number, linkers: string[]): Promise<boolean>;
+/**
+ *
+ * @param id the id of the concept whose connection needs to be returned
+ * @param linkers the connection types whose connection id need to be found
+ * @returns list of ids of the connection
+ */
+export declare function GetConnectionByTypeBulk(id: number, linkers: string[]): Promise<number[]>;

package/dist/types/Services/Delete/GetAllConnectionByType.d.ts

@@ -0,0 +1,16 @@
+import { Connection } from "../../app";
+/**
+ * This function returns all the connections from the ofTheConceptId and connection type
+ * @param id ofTheConceptId
+ * @param linker the connection type
+ * @param reverse if you put in reverse true then the reverse connections are returned.
+ * @returns Array of connections
+ */
+export declare function GetAllTheConnectionsByTypeAndOfTheConcept(id: number, linker: string, reverse?: boolean): Promise<Connection[]>;
+/**
+ * This function returns all the connections from the ofTheConceptId with toTheConceptId and linkers as given, the reverse is also true.
+ * @param id ofTheConceptId
+ * @param linker the connection type
+ * @returns Array of connections
+ */
+export declare function GiveConnection(ofTheConceptId: number, toTheConceptId: number, linker: string, reverse?: boolean): Promise<Connection[]>;

package/dist/types/Services/GetComposition.d.ts

@@ -32,13 +32,70 @@ export declare function RecursiveFetchBuildLayerDataId(id: number, connectionLis
  */
 export declare function RecursiveFetchBuildLayerNormal(id: number, connectionList: Connection[], compositionList: number[]): Promise<any>;
 /**
- * ## format JUSTDATA ##
- * this function builds the composition with the main id as the point of building.
- * This just requires the id
- * @param id id of the main composition that you want to build
- * @param connectionList  list of connections
- * @param compositionList list of of_the_concept_ids for all the connections.
- * @returns
+ * Retrieves a complete composition structure for a given concept ID in JUSTDATA format.
+ *
+ * This is a primary composition retrieval function that builds a hierarchical structure
+ * containing the main concept, all its connections, and recursively fetched related concepts.
+ * The result is formatted as a nested object organized by concept types.
+ *
+ * **What is a Composition?**
+ * A composition represents a concept along with its connected relationships and sub-structures.
+ * Think of it as getting a "full profile" of a concept including everything connected to it.
+ *
+ * **Process:**
+ * 1. Fetches all connections associated with the concept
+ * 2. Identifies all related concept IDs from those connections
+ * 3. Recursively builds the composition tree
+ * 4. Fetches the main concept details
+ * 5. Organizes output by concept type (e.g., result["Person"] = {...})
+ * 6. Routes through service worker if enabled for better performance
+ *
+ * **Output Format (JUSTDATA):**
+ * Returns an object keyed by the main concept's type character value:
+ * ```
+ * {
+ *   "Person": {
+ *     id: 123,
+ *     characterValue: "Alice",
+ *     connections: [...],
+ *     relatedConcepts: {...}
+ *   }
+ * }
+ * ```
+ *
+ * @param id - The unique identifier of the concept for which to build the composition.
+ *            This becomes the root of the composition tree.
+ *
+ * @returns Promise resolving to an object containing the composition data organized by
+ *         the main concept's type. Returns empty object if concept not found or on error.
+ *
+ * @example
+ * // Get composition for a person concept
+ * const composition = await GetComposition(12345);
+ * console.log(composition["Person"]);
+ * // {
+ * //   id: 12345,
+ * //   characterValue: "Alice Smith",
+ * //   connections: [... all connections],
+ * //   Company: { ... related company data },
+ * //   Projects: { ... related projects }
+ * // }
+ *
+ * @example
+ * // Get composition for an organization
+ * const orgComposition = await GetComposition(456);
+ * console.log(orgComposition["Organization"]);
+ * // Contains the organization and all connected employees, departments, etc.
+ *
+ * @example
+ * // Use with service worker (automatic if enabled)
+ * // Service worker handles the heavy lifting in background
+ * const result = await GetComposition(789);
+ *
+ * @see {@link GetCompositionWithId} for composition with ID and timestamp (DATAID format)
+ * @see {@link GetCompositionBulk} for fetching multiple compositions efficiently
+ * @see {@link GetCompositionWithCache} for cached composition retrieval
+ * @see {@link recursiveFetch} for the recursive building logic
  */
 export declare function GetComposition(id: number): Promise<any>;
 export declare function GetCompositionWithAllIds(id: number): Promise<any>;