mftsccs-node 0.0.60 → 0.0.63

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/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
@@ -259,4 +264,14 @@ export declare class BaseUrl {
      * @returns {string} The bulk type concept retrieval API endpoint
      */
     static GetConceptConnectionByType(): string;
+    /**
+     * Returns the URL for OAuth token requests.
+     * @returns {string} The OAuth token API endpoint
+     */
+    static OAuthTokenUrl(): string;
+    /**
+     * Returns the URL for OAuth token refresh requests.
+     * @returns {string} The OAuth token refresh API endpoint
+     */
+    static OAuthRefreshUrl(): string;
 }

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

@@ -0,0 +1,169 @@
+/**
+ * @fileoverview Configuration class for CCS initialization.
+ * This module provides a clean way to manage optional CCS configuration parameters.
+ * @module DataStructures/CCSConfig
+ */
+/**
+ * Configuration class for CCS initialization.
+ *
+ * This class holds all optional configuration parameters for the CCS library,
+ * keeping the init() function clean with only essential parameters.
+ *
+ * @class CCSConfig
+ *
+ * @example
+ * ```typescript
+ * const config = new CCSConfig({
+ *     aiUrl: "https://ai.example.com",
+ *     accessToken: "jwt-token",
+ *     enableAi: true,
+ *     flags: { logApplication: true },
+ *     storagePath: "./data/ccs/"
+ * });
+ *
+ * await init(
+ *     "https://api.example.com",
+ *     "http://localhost:5001",
+ *     "MyApp",
+ *     config
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Minimal configuration with OAuth
+ * const config = new CCSConfig({
+ *     clientId: "101084838",
+ *     clientSecret: "your-secret"
+ * });
+ *
+ * await init("https://api.example.com", "", "MyApp", config);
+ * ```
+ */
+export declare class CCSConfig {
+    /** URL for the AI service. Defaults to "https://ai.freeschema.com" */
+    aiUrl: string;
+    /** JWT bearer token for authentication. Can be set later via updateAccessToken() */
+    accessToken: string;
+    /** Whether to enable AI features. Defaults to true */
+    enableAi: boolean;
+    /**
+     * Dictionary of feature flags for controlling CCS behavior.
+     * Available flags:
+     * - logApplication: Enable application-level logging
+     * - logPackage: Enable package-level logging
+     * - accessTracker: Enable access tracking
+     * - isTest: Enable test mode
+     */
+    flags?: Record<string, boolean>;
+    /**
+     * Dictionary of additional parameters.
+     * Example: { logserver: "https://logs.example.com" }
+     */
+    parameters?: Record<string, string>;
+    /** Path for storing local data (ID counters, cached data, etc.) */
+    storagePath?: string;
+    /** OAuth client ID for authentication */
+    clientId?: string;
+    /** OAuth client secret for authentication */
+    clientSecret?: string;
+    /** Application name for OAuth and logging purposes */
+    applicationName?: string;
+    /**
+     * Creates a new CCSConfig instance.
+     *
+     * @param options - Partial configuration options to override defaults
+     *
+     * @example
+     * ```typescript
+     * // Use default values
+     * const config = new CCSConfig();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Override specific values
+     * const config = new CCSConfig({
+     *     aiUrl: "https://custom-ai.example.com",
+     *     enableAi: false,
+     *     clientId: "123456",
+     *     clientSecret: "secret",
+     *     flags: {
+     *         logApplication: true,
+     *         accessTracker: true
+     *     }
+     * });
+     * ```
+     */
+    constructor(options?: Partial<CCSConfig>);
+    /**
+     * Returns true if OAuth credentials are configured.
+     * @returns {boolean} Whether both clientId and clientSecret are set
+     */
+    hasOAuthCredentials(): boolean;
+    /**
+     * Returns true if an access token is configured.
+     * @returns {boolean} Whether accessToken is set
+     */
+    hasAccessToken(): boolean;
+    /**
+     * Get a specific flag value with a default fallback.
+     *
+     * @param flagName - The name of the flag to retrieve
+     * @param defaultValue - Default value if flag is not set
+     * @returns {boolean} The flag value or default
+     *
+     * @example
+     * ```typescript
+     * const config = new CCSConfig({
+     *     flags: { logApplication: true }
+     * });
+     * config.getFlag('logApplication', false); // returns true
+     * config.getFlag('unknownFlag', false);     // returns false
+     * ```
+     */
+    getFlag(flagName: string, defaultValue?: boolean): boolean;
+    /**
+     * Get a specific parameter value with a default fallback.
+     *
+     * @param paramName - The name of the parameter to retrieve
+     * @param defaultValue - Default value if parameter is not set
+     * @returns {string} The parameter value or default
+     *
+     * @example
+     * ```typescript
+     * const config = new CCSConfig({
+     *     parameters: { logserver: "https://logs.example.com" }
+     * });
+     * config.getParameter('logserver', ''); // returns "https://logs.example.com"
+     * config.getParameter('unknown', '');   // returns ""
+     * ```
+     */
+    getParameter(paramName: string, defaultValue?: string): string;
+    /**
+     * Set a flag value.
+     *
+     * @param flagName - The name of the flag to set
+     * @param value - The boolean value to set
+     *
+     * @example
+     * ```typescript
+     * const config = new CCSConfig();
+     * config.setFlag('logApplication', true);
+     * ```
+     */
+    setFlag(flagName: string, value: boolean): void;
+    /**
+     * Set a parameter value.
+     *
+     * @param paramName - The name of the parameter to set
+     * @param value - The string value to set
+     *
+     * @example
+     * ```typescript
+     * const config = new CCSConfig();
+     * config.setParameter('logserver', 'https://logs.example.com');
+     * ```
+     */
+    setParameter(paramName: string, value: string): void;
+}

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/Security/TokenStorage.d.ts

@@ -48,4 +48,78 @@ export declare class TokenStorage {
      * Consider clearing this value on logout or session expiration.
      */
     static BearerAccessToken: string;
+    /**
+     * OAuth client ID for token refresh
+     * @static
+     * @type {string}
+     * @default ""
+     */
+    static CLIENT_ID: string;
+    /**
+     * OAuth client secret for token refresh
+     * @static
+     * @type {string}
+     * @default ""
+     */
+    static CLIENT_SECRET: string;
+    /**
+     * Application name for OAuth
+     * @static
+     * @type {string}
+     * @default ""
+     */
+    static APPLICATION_NAME: string;
+    /**
+     * Token expiration timestamp (Unix timestamp in milliseconds)
+     * @static
+     * @type {number}
+     * @default 0
+     */
+    static TOKEN_EXPIRY: number;
+    /**
+     * Buffer time before token expiry to trigger refresh (in milliseconds)
+     * Default: 5 minutes (300000 ms)
+     * @static
+     * @type {number}
+     */
+    static EXPIRY_BUFFER_MS: number;
+    /**
+     * Gets authorization header object for HTTP requests.
+     * @returns {Record<string, string>} Headers object with Authorization header if token exists
+     *
+     * @example
+     * ```typescript
+     * const headers = TokenStorage.getAuthHeader();
+     * // Returns: { 'Authorization': 'Bearer your-token' } or {}
+     * ```
+     */
+    static getAuthHeader(): Record<string, string>;
+    /**
+     * Sets the access token and calculates expiry time.
+     * @param token - The access token
+     * @param expiresIn - Token lifetime in seconds (optional)
+     */
+    static setToken(token: string, expiresIn?: number): void;
+    /**
+     * Checks if the token is expired or near expiry.
+     * @returns {boolean} True if token is expired or within the buffer window
+     */
+    static isTokenExpiredOrNearExpiry(): boolean;
+    /**
+     * Gets the remaining time until token expiry in seconds.
+     * @returns {number} Seconds until expiry, or -1 if expired/no expiry set
+     */
+    static getTimeUntilExpiry(): number;
+    /**
+     * Checks if OAuth credentials are configured for automatic token refresh.
+     * @returns {boolean} True if client ID, secret, and app name are all set
+     */
+    static hasOAuthCredentials(): boolean;
+    /**
+     * Sets OAuth credentials for automatic token refresh.
+     * @param clientId - OAuth client ID
+     * @param clientSecret - OAuth client secret
+     * @param applicationName - Application name
+     */
+    static setOAuthCredentials(clientId: string, clientSecret: string, applicationName: string): 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/Services/AccessControl/AccessControlCacheService.d.ts

@@ -0,0 +1,19 @@
+import { PermissionSet } from './PermissionSet';
+export declare class AccessControlCacheService {
+    private readonly userAccessCache;
+    private readonly publicAccessCache;
+    private readonly baseUrl;
+    constructor();
+    loadCacheFromApi(entityId?: number): Promise<void>;
+    loadCacheFromJson(jsonData: any): void;
+    hasAccess(entityId: number, conceptId: number, required: PermissionSet): Promise<boolean>;
+    getAccessibleConcepts(entityId: number, conceptIds: number[], required: PermissionSet): Promise<number[]>;
+    getAccessByUser(entityId: number): Promise<Map<number, PermissionSet>>;
+    getAccessByConcept(conceptId: number): Promise<Map<number, PermissionSet>>;
+    deleteRecordByUserId(entityId: number): void;
+    deletePublicAccessRecordById(conceptId: number): void;
+    clearCache(): void;
+    getConceptsByPublicAccess(): Promise<Record<number, string[]>>;
+    hasPublicAccess(conceptId: number, required: PermissionSet): Promise<boolean>;
+    getConceptsWithPublicAccess(conceptIds: number[], required: PermissionSet): Promise<number[]>;
+}

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/Common/ErrorPosting.d.ts

@@ -2,6 +2,7 @@
  * @module ErrorPosting
  * @description Provides error handling functions for HTTP and internal errors with structured error responses
  */
+import { HttpResponse } from "../Http/HttpClient.service";
 /**
  * Handles HTTP errors by creating and throwing structured error responses.
  * Specifically handles 401 Unauthorized errors.
@@ -23,6 +24,7 @@
  * - Useful for API call error handling
  */
 export declare function HandleHttpError(response: Response): void;
+export declare function HandleHttpErrorHttp(response: HttpResponse): void;
 /**
  * Handles internal application errors by creating and throwing structured error responses.
  * Wraps any error object into a FreeSchemaResponse.