mftsccs-node 0.0.60 → 0.0.63

package/dist/types/Services/Http/HttpClient.service.d.ts

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview HTTP Client - Handles API requests with automatic token refresh on 401 errors.
+ * This module provides a robust HTTP client that automatically refreshes OAuth tokens
+ * when receiving 401 Unauthorized responses, ensuring seamless API access.
+ * @module Services/Http/HttpClient
+ */
+/**
+ * Custom error thrown when token refresh fails.
+ */
+export declare class TokenRefreshError extends Error {
+    constructor(message: string);
+}
+/**
+ * Container for HTTP response data.
+ * Provides convenient methods to parse response body as JSON or text.
+ */
+export declare class HttpResponse {
+    status: number;
+    body: string;
+    headers: Record<string, string>;
+    /**
+     * Creates a new HttpResponse instance.
+     * @param status - HTTP status code
+     * @param body - Response body as string
+     * @param headers - Response headers
+     */
+    constructor(status: number, body: string, headers: Record<string, string>);
+    /**
+     * Parse response body as JSON.
+     * @returns {Promise<any>} Parsed JSON object
+     *
+     * @example
+     * ```typescript
+     * const response = await requestWithRetry('GET', url);
+     * const data = await response.json();
+     * console.log(data.id);
+     * ```
+     */
+    json(): Promise<any>;
+    /**
+     * Get response body as text.
+     * @returns {Promise<string>} Response body as string
+     *
+     * @example
+     * ```typescript
+     * const response = await requestWithRetry('GET', url);
+     * const text = await response.text();
+     * console.log(text);
+     * ```
+     */
+    text(): Promise<string>;
+    /**
+     * Checks if the response status indicates success (200-299).
+     * @returns {boolean} True if status is in the 2xx range
+     */
+    get ok(): boolean;
+}
+/**
+ * Make an HTTP request with automatic retry on 401 Unauthorized.
+ *
+ * If a 401 error occurs and OAuth credentials are available, this function
+ * will automatically refresh the token and retry the request once.
+ *
+ * @async
+ * @param {string} method - HTTP method (GET, POST, PUT, DELETE, etc.)
+ * @param {string} url - The URL to request
+ * @param {Record<string, string>} [headers] - Optional headers dict
+ * @param {any} [body] - Optional request body (JSON will be stringified)
+ * @param {number} [maxRetries=1] - Maximum number of retries on 401
+ * @returns {Promise<HttpResponse>} HttpResponse object with status, body, and headers
+ * @throws {TokenRefreshError} If token refresh fails
+ * @throws {Error} For other network errors
+ *
+ * @example
+ * ```typescript
+ * const headers = { "Content-Type": "application/json" };
+ * const response = await requestWithRetry(
+ *     "POST",
+ *     url,
+ *     headers,
+ *     { id: 123 }
+ * );
+ * if (response.ok) {
+ *     const data = await response.json();
+ *     console.log(data);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Automatic token refresh on 401
+ * try {
+ *     const response = await requestWithRetry("GET", url);
+ *     // If receives 401, will automatically refresh token and retry
+ * } catch (error) {
+ *     if (error instanceof TokenRefreshError) {
+ *         console.error('Authentication failed:', error.message);
+ *     }
+ * }
+ * ```
+ */
+export declare function requestWithRetry(method: string, url: string, headers?: Record<string, string>, body?: any, maxRetries?: number): Promise<HttpResponse>;
+/**
+ * Convenience method for POST requests with automatic retry on 401.
+ *
+ * @async
+ * @param {string} url - The URL to request
+ * @param {Record<string, string>} [headers] - Optional headers dict
+ * @param {any} [body] - Optional request body (will be JSON stringified if object)
+ * @returns {Promise<HttpResponse>} HttpResponse object
+ *
+ * @example
+ * ```typescript
+ * const response = await postWithRetry(
+ *     "https://api.example.com/concepts",
+ *     { "Content-Type": "application/json" },
+ *     { name: "Test", value: 123 }
+ * );
+ * if (response.ok) {
+ *     const data = await response.json();
+ *     console.log('Created:', data);
+ * }
+ * ```
+ */
+export declare function postWithRetry(url: string, headers?: Record<string, string>, body?: any): Promise<HttpResponse>;
+/**
+ * Convenience method for GET requests with automatic retry on 401.
+ *
+ * @async
+ * @param {string} url - The URL to request
+ * @param {Record<string, string>} [headers] - Optional headers dict
+ * @param {Record<string, any>} [params] - Optional query parameters
+ * @returns {Promise<HttpResponse>} HttpResponse object
+ *
+ * @example
+ * ```typescript
+ * const response = await getWithRetry(
+ *     "https://api.example.com/concepts",
+ *     undefined,
+ *     { id: 123, type: "test" }
+ * );
+ * if (response.ok) {
+ *     const data = await response.json();
+ *     console.log(data);
+ * }
+ * ```
+ */
+export declare function getWithRetry(url: string, headers?: Record<string, string>, params?: Record<string, any>): Promise<HttpResponse>;
+/**
+ * Convenience method for PUT requests with automatic retry on 401.
+ *
+ * @async
+ * @param {string} url - The URL to request
+ * @param {Record<string, string>} [headers] - Optional headers dict
+ * @param {any} [body] - Optional request body
+ * @returns {Promise<HttpResponse>} HttpResponse object
+ *
+ * @example
+ * ```typescript
+ * const response = await putWithRetry(
+ *     "https://api.example.com/concepts/123",
+ *     { "Content-Type": "application/json" },
+ *     { name: "Updated Name" }
+ * );
+ * ```
+ */
+export declare function putWithRetry(url: string, headers?: Record<string, string>, body?: any): Promise<HttpResponse>;
+/**
+ * Convenience method for DELETE requests with automatic retry on 401.
+ *
+ * @async
+ * @param {string} url - The URL to request
+ * @param {Record<string, string>} [headers] - Optional headers dict
+ * @returns {Promise<HttpResponse>} HttpResponse object
+ *
+ * @example
+ * ```typescript
+ * const response = await deleteWithRetry(
+ *     "https://api.example.com/concepts/123"
+ * );
+ * if (response.ok) {
+ *     console.log('Deleted successfully');
+ * }
+ * ```
+ */
+export declare function deleteWithRetry(url: string, headers?: Record<string, string>): Promise<HttpResponse>;
+/**
+ * Convenience method for PATCH requests with automatic retry on 401.
+ *
+ * @async
+ * @param {string} url - The URL to request
+ * @param {Record<string, string>} [headers] - Optional headers dict
+ * @param {any} [body] - Optional request body
+ * @returns {Promise<HttpResponse>} HttpResponse object
+ *
+ * @example
+ * ```typescript
+ * const response = await patchWithRetry(
+ *     "https://api.example.com/concepts/123",
+ *     { "Content-Type": "application/json" },
+ *     { status: "active" }
+ * );
+ * ```
+ */
+export declare function patchWithRetry(url: string, headers?: Record<string, string>, body?: any): Promise<HttpResponse>;

package/dist/types/Services/Security/GetRequestHeader.d.ts

@@ -1,10 +1,58 @@
-export declare function GetRequestHeader(contentType?: string, Accept?: string): {
-    'Content-Type': string;
-    Authorization: string;
-    Accept: string;
-};
-export declare function GetRequestHeaderWithAuthorization(contentType?: string, token?: string, Accept?: string): {
-    'Content-Type': string;
-    Authorization: string;
-    Accept: string;
-};
+/**
+ * Gets request headers with automatic token refresh if expired or near expiry.
+ * This is the async version that checks token expiry and refreshes if needed.
+ *
+ * @async
+ * @param {string} [contentType='application/json'] - Content-Type header value
+ * @param {string} [Accept='application/json'] - Accept header value
+ * @returns {Promise<Record<string, string>>} Headers object with refreshed token if needed
+ *
+ * @example
+ * ```typescript
+ * // Automatically refreshes token if expired/near expiry
+ * const headers = await GetRequestHeaderWithRefresh();
+ * const response = await fetch(url, { headers });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With custom content type
+ * const headers = await GetRequestHeaderWithRefresh('application/x-www-form-urlencoded');
+ * ```
+ */
+export declare function GetRequestHeader(contentType?: string, Accept?: string): Promise<Record<string, string>>;
+/**
+ * Gets request headers with automatic token refresh and custom token override.
+ * This is the async version that checks token expiry and refreshes if needed.
+ *
+ * @async
+ * @param {string} [contentType='application/json'] - Content-Type header value
+ * @param {string} [token=''] - Optional token override. If empty, uses TokenStorage token
+ * @param {string} [Accept='application/json'] - Accept header value
+ * @returns {Promise<Record<string, string>>} Headers object with refreshed token if needed
+ *
+ * @example
+ * ```typescript
+ * // Use stored token with automatic refresh
+ * const headers = await GetRequestHeaderWithAuthorizationAndRefresh();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use custom token (no refresh)
+ * const headers = await GetRequestHeaderWithAuthorizationAndRefresh(
+ *     'application/json',
+ *     'custom-token-here'
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Check token expiry status
+ * const timeRemaining = TokenStorage.getTimeUntilExpiry();
+ * console.log(`Token expires in ${timeRemaining} seconds`);
+ *
+ * const headers = await GetRequestHeaderWithAuthorizationAndRefresh();
+ * ```
+ */
+export declare function GetRequestHeaderWithAuthorization(contentType?: string, token?: string, Accept?: string): Promise<Record<string, string>>;

package/dist/types/Services/oauth/CallOauth.service.d.ts

@@ -0,0 +1,101 @@
+/**
+ * @fileoverview OAuth API - Handles OAuth token requests for authentication.
+ * This module provides functions for obtaining and refreshing OAuth access tokens
+ * from the authentication server.
+ * @module Services/oauth/CallOauth
+ */
+/**
+ * Response from OAuth token request.
+ * Contains either successful token data or error information.
+ *
+ * @interface OAuthResponse
+ */
+export interface OAuthResponse {
+    /** Whether the OAuth request was successful */
+    success: boolean;
+    /** The OAuth access token (empty if request failed) */
+    access_token?: string;
+    /** The token type (typically "Bearer") */
+    token_type?: string;
+    /** Number of seconds until the token expires */
+    expires_in?: number;
+    /** Error message if the request failed */
+    error?: string;
+}
+/**
+ * Request an OAuth access token from the server.
+ *
+ * This function authenticates with the OAuth endpoint using client credentials
+ * and returns an access token that can be used for API requests.
+ *
+ * @async
+ * @param {string} client_id - The OAuth client ID.
+ * @param {string} client_secret - The OAuth client secret.
+ * @param {string} application_name - The name of the application requesting the token.
+ * @param {boolean} [auto_set_token=true] - If true, automatically sets the token in TokenStorage
+ *                                          for subsequent API calls.
+ * @returns {Promise<OAuthResponse>} OAuthResponse with the access token if successful,
+ *                                    or error details if failed.
+ *
+ * @example
+ * ```typescript
+ * import { getOAuthToken } from './Services/oauth/CallOauth.service';
+ *
+ * const response = await getOAuthToken(
+ *     "101084838",
+ *     "your-client-secret",
+ *     "myapp"
+ * );
+ * if (response.success) {
+ *     console.log(`Token: ${response.access_token}`);
+ * } else {
+ *     console.log(`Error: ${response.error}`);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Get token without auto-setting
+ * const response = await getOAuthToken(
+ *     "101084838",
+ *     "secret",
+ *     "myapp",
+ *     false
+ * );
+ * // Manually set token later
+ * if (response.success) {
+ *     TokenStorage.BearerAccessToken = response.access_token || "";
+ * }
+ * ```
+ */
+export declare function getOAuthToken(client_id: string, client_secret: string, application_name: string, auto_set_token?: boolean): Promise<OAuthResponse>;
+/**
+ * Refresh an OAuth access token using a refresh token.
+ *
+ * This function uses a refresh token from a previous authentication to obtain
+ * a new access token without requiring the user to re-authenticate.
+ *
+ * @async
+ * @param {string} client_id - The OAuth client ID.
+ * @param {string} client_secret - The OAuth client secret.
+ * @param {string} refresh_token - The refresh token from a previous authentication.
+ * @param {boolean} [auto_set_token=true] - If true, automatically sets the new token in TokenStorage.
+ * @returns {Promise<OAuthResponse>} OAuthResponse with the new access token if successful.
+ *
+ * @example
+ * ```typescript
+ * import { refreshOAuthToken } from './Services/oauth/CallOauth.service';
+ *
+ * const response = await refreshOAuthToken(
+ *     "101084838",
+ *     "your-client-secret",
+ *     "your-refresh-token"
+ * );
+ * if (response.success) {
+ *     console.log(`New Token: ${response.access_token}`);
+ * } else {
+ *     console.log(`Error: ${response.error}`);
+ * }
+ * ```
+ */
+export declare function refreshOAuthToken(client_id: string, client_secret: string, refresh_token: string, auto_set_token?: boolean): Promise<OAuthResponse>;

package/dist/types/app.d.ts

@@ -7,7 +7,10 @@
  * @see {@link https://documentation.freeschema.com} for detailed documentation
  */
 export { init, updateAccessToken };
+export { getOAuthToken, refreshOAuthToken, OAuthResponse } from './Services/oauth/CallOauth.service';
+export { requestWithRetry, postWithRetry, getWithRetry, putWithRetry, deleteWithRetry, patchWithRetry, HttpResponse, TokenRefreshError } from './Services/Http/HttpClient.service';
 export { SplitStrings } from './Services/SplitStrings';
+export { GetRequestHeader, GetRequestHeaderWithAuthorization } from './Services/Security/GetRequestHeader';
 export { GetCompositionList, GetCompositionListWithId } from './Services/GetCompositionList';
 export { GetCompositionListLocal, GetCompositionListLocalWithId } from './Services/Local/GetCompositionListLocal';
 export { GetAllConnectionsOfComposition } from './Api/GetAllConnectionsOfComposition';
@@ -28,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';
@@ -89,10 +92,15 @@ export { UserBinaryTree } from './DataStructures/User/UserBinaryTree';
 export { FilterSearch } from './DataStructures/FilterSearch';
 export { SearchStructure } from './DataStructures/Search/SearchStructure';
 export { FreeSchemaResponse } from './DataStructures/Responses/ErrorResponse';
+export { CCSConfig } from './DataStructures/CCSConfig';
+import { CCSConfig } from './DataStructures/CCSConfig';
 export { BaseUrl } from './DataStructures/BaseUrl';
+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 { Transaction } from './DataStructures/Transaction/Transaction';
 /**
@@ -117,7 +125,7 @@ declare function updateAccessToken(accessToken?: string): void;
  * It performs the following operations asynchronously:
  *
  * 1. Sets up base URLs for the main API and AI services
- * 2. Stores the authentication token for API requests
+ * 2. Stores the authentication token for API requests (or obtains one via OAuth)
  * 3. Initializes the system (database setup)
  * 4. Creates binary trees from concept data for efficient querying (by ID, character, and type)
  * 5. Creates local binary trees for offline/local concept management
@@ -128,22 +136,54 @@ declare function updateAccessToken(accessToken?: string): void;
  * are updated as each operation completes to indicate which data structures are ready for use.
  *
  * @param url - The base URL for the main backend API endpoint (e.g., 'https://api.example.com')
- * @param aiurl - The base URL for the AI service endpoint (e.g., 'https://ai.example.com')
- * @param accessToken - The bearer access token for authenticating API requests
+ * @param nodeUrl - The base URL for the Node.js service endpoint (optional)
+ * @param applicationName - The name of the application (used for OAuth and logging)
+ * @param config - Optional CCSConfig object containing all optional configuration parameters
  *
  * @example
  * ```typescript
- * // Initialize the system with backend URLs and auth token
- * init(
- *   'https://api.freeschema.com',
- *   'https://ai.freeschema.com',
- *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
- * );
+ * // Simple initialization with just URL
+ * init('https://api.freeschema.com');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Initialize with access token
+ * const config = new CCSConfig({
+ *     accessToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+ * });
+ * init('https://api.freeschema.com', '', 'MyApp', config);
+ * ```
  *
- * // After initialization, check if data is loaded before querying
- * if (IdentifierFlags.isDataLoaded) {
- *   // Safe to query concepts
- * }
+ * @example
+ * ```typescript
+ * // Initialize with OAuth credentials
+ * const config = new CCSConfig({
+ *     clientId: '101084838',
+ *     clientSecret: 'your-client-secret',
+ *     aiUrl: 'https://ai.freeschema.com',
+ *     enableAi: true
+ * });
+ * init('https://api.freeschema.com', '', 'MyApp', config);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Full configuration
+ * const config = new CCSConfig({
+ *     aiUrl: 'https://ai.example.com',
+ *     accessToken: 'token',
+ *     enableAi: true,
+ *     flags: {
+ *         logApplication: true,
+ *         accessTracker: true
+ *     },
+ *     parameters: {
+ *         logserver: 'https://logs.example.com'
+ *     },
+ *     storagePath: './data/ccs/'
+ * });
+ * init('https://api.example.com', 'http://localhost:5001', 'MyApp', config);
  * ```
  *
  * @remarks
@@ -154,9 +194,10 @@ declare function updateAccessToken(accessToken?: string): void;
  * - `isConnectionLoaded`, `isConnectionTypeLoaded` - Remote connection data ready
  * - `isLocalConnectionLoaded` - Local connection data ready
  *
+ * @see CCSConfig for all available configuration options
  * @see IdentifierFlags for checking initialization status
  * @see InitializeSystem for database initialization details
  * @see CreateBinaryTreeFromData for concept tree creation
  * @see https://documentation.freeschema.com/#installation for setup guide
  */
-declare function init(url?: string, aiurl?: string, accessToken?: string): void;
+declare function init(url?: string, nodeUrl?: string, applicationName?: string, config?: CCSConfig): void;