mftsccs-node 0.0.56 → 0.0.58

package/dist/types/Api/SearchConcept/GetConceptByCharacterAndCategoryDirect.d.ts

@@ -0,0 +1,49 @@
+/**
+ * API module for searching concepts by character value with explicit category specification.
+ * Provides direct category-based concept retrieval with request caching.
+ *
+ * @module Api/SearchConcept/GetConceptByCharacterAndCategoryDirect
+ * @see https://documentation.freeschema.com for reference
+ */
+import { Concept } from "./../../DataStructures/Concept";
+/**
+ * Retrieves a concept from the backend by its character value and specific category ID.
+ * This is a more precise search than GetConceptByCharacterAndCategoryApi as it requires
+ * an explicit category ID.
+ *
+ * The function uses request caching to prevent duplicate simultaneous requests for the
+ * same character-category combination. Retrieved concepts are automatically added to
+ * the local ConceptsData cache.
+ *
+ * @param characterValue - The character string identifying the concept (e.g., "john_doe", "building_a")
+ * @param category_id - The specific category ID to search within
+ * @returns A promise that resolves to the matching Concept object, or a default concept if not found
+ *
+ * @example
+ * ```typescript
+ * // Find a specific person concept in category 5
+ * const person = await GetConceptByCharacterAndCategoryDirectApi('john_doe', 5);
+ * if (person.id !== 0) {
+ *   console.log('Found person:', person);
+ * }
+ *
+ * // Simultaneous calls for the same concept will use the same cached promise
+ * const promise1 = GetConceptByCharacterAndCategoryDirectApi('jane_doe', 5);
+ * const promise2 = GetConceptByCharacterAndCategoryDirectApi('jane_doe', 5);
+ * // Both will resolve to the same result without making duplicate API calls
+ * ```
+ *
+ * @remarks
+ * - Uses local caching (conceptCache) to prevent duplicate simultaneous requests
+ * - Cache key is the concatenation of characterValue and category_id
+ * - Returns a default concept (id=0) if the concept is not found or an error occurs
+ * - Automatically caches the retrieved concept in ConceptsData for subsequent use
+ * - Cache entries are cleaned up in the finally block after fetch completes
+ * - HTTP errors are handled through HandleHttpError but do not throw
+ * - Errors are logged with full diagnostic information including the endpoint URL
+ *
+ * @see GetConceptByCharacterAndCategoryApi for searching without explicit category
+ * @see CreateDefaultConcept for the default concept structure
+ * @see ConceptsData for the local concept cache
+ */
+export declare function GetConceptByCharacterAndCategoryDirectApi(characterValue: string, category_id: number): Promise<Concept>;

package/dist/types/Api/Session/CreateSession.d.ts

@@ -0,0 +1,47 @@
+/**
+ * API module for creating user session records.
+ * Tracks user sessions for analytics and activity monitoring purposes.
+ *
+ * @module Api/Session/CreateSession
+ * @see https://documentation.freeschema.com for reference
+ */
+import { SessionData } from "../../app";
+/**
+ * Creates a new session record in the backend for tracking user activity.
+ * Sessions are used to monitor user interactions, track analytics, and maintain
+ * activity logs within the Concept Connection System.
+ *
+ * This function initiates a new session with the provided session data, which
+ * typically includes user information, timestamps, and session metadata.
+ *
+ * @param sessionData - The session data object containing session initialization information
+ * @returns A promise that resolves to the created session response, or null if creation fails
+ *
+ * @example
+ * ```typescript
+ * // Create a new user session
+ * const sessionInfo: SessionData = {
+ *   userId: 123,
+ *   startTime: new Date().toISOString(),
+ *   userAgent: navigator.userAgent
+ * };
+ *
+ * const session = await CreateSession(sessionInfo);
+ * if (session) {
+ *   console.log('Session created:', session.sessionId);
+ * } else {
+ *   console.log('Session creation failed');
+ * }
+ * ```
+ *
+ * @remarks
+ * - Returns null if the session creation fails
+ * - HTTP errors are handled through HandleHttpError
+ * - Requires authentication via GetRequestHeader
+ * - Error details are logged to console for debugging
+ * - Errors are re-thrown for caller handling
+ *
+ * @see CreateSessionVisit for tracking URL visits within a session
+ * @see SessionData for the session data structure
+ */
+export declare function CreateSession(sessionData: SessionData): Promise<any>;

package/dist/types/Api/Session/CreateSessionVisit.d.ts

@@ -0,0 +1,44 @@
+/**
+ * API module for tracking URL visits within user sessions.
+ * Records individual page/URL visits as part of session activity tracking.
+ *
+ * @module Api/Session/CreateSessionVisit
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Records a URL visit within an existing session for activity tracking.
+ * This function creates a session visit record that tracks which URLs a user
+ * accesses during their session, useful for analytics and navigation tracking.
+ *
+ * Session visits help build a complete picture of user activity by recording
+ * each page or resource accessed during a session in the Concept Connection System.
+ *
+ * @param sessionId - The unique identifier of the session to associate this visit with
+ * @param url - The URL that was visited (page path or full URL)
+ * @returns A promise that resolves to the created visit response, or null if creation fails
+ *
+ * @example
+ * ```typescript
+ * // Track a page visit within a session
+ * const visit = await CreateSessionVisit(456, '/concepts/dashboard');
+ * if (visit) {
+ *   console.log('Visit tracked:', visit);
+ * }
+ *
+ * // Track multiple visits in sequence
+ * await CreateSessionVisit(456, '/concepts/search');
+ * await CreateSessionVisit(456, '/concepts/create');
+ * await CreateSessionVisit(456, '/concepts/view/123');
+ * ```
+ *
+ * @remarks
+ * - Returns null if the visit creation fails
+ * - HTTP errors are handled through HandleHttpError
+ * - Requires authentication via GetRequestHeader
+ * - Uses URL-encoded form data for the request body
+ * - Error details are logged to console for debugging
+ * - Errors are re-thrown for caller handling
+ *
+ * @see CreateSession for creating the initial session
+ */
+export declare function CreateSessionVisit(sessionId: number, url: string): Promise<any>;

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

@@ -0,0 +1,51 @@
+/**
+ * API module for user sign-in operations.
+ * Provides standardized authentication with structured response handling.
+ *
+ * @module Api/Signin
+ * @see https://documentation.freeschema.com for reference
+ */
+import { FreeschemaResponse } from "../DataStructures/Responses/StandardResponses";
+import { SigninModel } from "../DataStructures/SigninModel";
+/**
+ * Authenticates a user and returns a standardized Freeschema response.
+ * This function provides a more structured authentication approach compared to LoginToBackend,
+ * returning a FreeschemaResponse object with consistent status and data fields.
+ *
+ * The signin process validates user credentials and returns authentication data including
+ * tokens and user information in a standardized response format.
+ *
+ * @param signinInfo - The signin model containing user credentials (email and password)
+ * @returns A promise that resolves to a FreeschemaResponse containing authentication data
+ *
+ * @example
+ * ```typescript
+ * // Sign in a user with standardized response
+ * const signinData: SigninModel = {
+ *   email: 'user@example.com',
+ *   password: 'securePassword123'
+ * };
+ *
+ * const response = await Signin(signinData);
+ * if (response.status && response.statusCode === 200) {
+ *   console.log('Signin successful:', response.data);
+ *   // Use response.data.token for subsequent API calls
+ * } else {
+ *   console.error('Signin failed:', response.message);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Returns a FreeschemaResponse with status, statusCode, message, and data fields
+ * - On success: status=true, statusCode=200, data contains authentication information
+ * - On failure: status=false, statusCode and message indicate the error
+ * - HTTP errors are handled through HandleHttpError
+ * - Errors are logged to console and re-thrown for caller handling
+ * - Uses JSON content-type for request body
+ *
+ * @see LoginToBackend for alternative login implementation
+ * @see Signup for user registration
+ * @see SigninModel for the signin data structure
+ * @see FreeschemaResponse for the response structure
+ */
+export default function Signin(signinInfo: SigninModel): Promise<FreeschemaResponse>;

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

@@ -0,0 +1,47 @@
+/**
+ * API module for user registration and signup operations.
+ * Handles new user account creation with standardized response handling.
+ *
+ * @module Api/Signup
+ * @see https://documentation.freeschema.com for reference
+ */
+import { FreeschemaResponse } from "../DataStructures/Responses/StandardResponses";
+import { SignupModel } from "../DataStructures/SignupModel";
+/**
+ * Registers a new user account in the Concept Connection System.
+ * This function creates a new user with the provided signup information and returns
+ * a standardized response containing registration results.
+ *
+ * @param signupModel - The signup model containing user registration information (name, email, password, etc.)
+ * @returns A promise that resolves to a FreeschemaResponse indicating success or failure
+ *
+ * @example
+ * ```typescript
+ * // Register a new user
+ * const newUser: SignupModel = {
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   password: 'securePassword123'
+ * };
+ *
+ * const response = await Signup(newUser);
+ * if (response.status && response.statusCode === 200) {
+ *   console.log('Signup successful:', response.data);
+ * } else {
+ *   console.error('Signup failed:', response.message);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Returns a FreeschemaResponse with status, statusCode, message, and data fields
+ * - On success: status=true, statusCode=200, data contains user information
+ * - On failure: status=false with error details
+ * - HTTP errors are handled through HandleHttpError
+ * - Errors are logged to console and re-thrown for caller handling
+ *
+ * @see Signin for user authentication after signup
+ * @see LoginToBackend for alternative login
+ * @see SignupModel for the signup data structure
+ * @see FreeschemaResponse for the response structure
+ */
+export default function Signup(signupModel: SignupModel): Promise<FreeschemaResponse>;

package/dist/types/Api/View/ViewInternalDataApi.d.ts

@@ -0,0 +1,51 @@
+/**
+ * API module for viewing internal concept data and connections.
+ * Retrieves detailed internal structure including connections for specified concepts.
+ *
+ * @module Api/View/ViewInternalDataApi
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Retrieves internal data and connections for a list of concept IDs.
+ * This function fetches the internal composition structure of concepts, including all
+ * sub-concepts and their interconnections, providing a complete view of concept internals.
+ *
+ * In the Concept Connection System, concepts can contain other concepts as part of their
+ * internal structure (composition). This function retrieves those internal concepts and
+ * the connections between them, returning a dictionary mapping concept IDs to their
+ * internal connection lists.
+ *
+ * @param ids - Array of concept IDs to retrieve internal data for
+ * @returns A promise that resolves to a dictionary mapping concept IDs to their internal connections,
+ *          or an empty connection list if the request fails
+ *
+ * @example
+ * ```typescript
+ * // View internal data for multiple concepts
+ * const conceptIds = [100, 101, 102];
+ * const internalData = await ViewInternalDataApi(conceptIds);
+ *
+ * // Access connections for a specific concept
+ * const concept100Connections = internalData[100];
+ * if (concept100Connections) {
+ *   console.log('Concept 100 has', concept100Connections.length, 'internal connections');
+ * }
+ *
+ * // Process all internal structures
+ * for (const [conceptId, connections] of Object.entries(internalData)) {
+ *   console.log(`Concept ${conceptId}:`, connections);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Returns an object where keys are concept IDs and values are arrays of Connection objects
+ * - Automatically fetches and caches all sub-concepts via GetConceptBulk
+ * - Returns an empty connection list on error
+ * - HTTP errors are handled through HandleHttpError but do not throw
+ * - Requires authentication via GetRequestHeader
+ * - Errors are logged to console and re-thrown for caller handling
+ *
+ * @see GetConceptBulk for bulk concept retrieval
+ * @see Connection for the connection data structure
+ */
+export declare function ViewInternalDataApi(ids: number[]): Promise<any>;

package/dist/types/Constants/ApiConstants.d.ts

@@ -0,0 +1,249 @@
+/**
+ * API Constants Module for Concept Connection System (CCS-JS)
+ *
+ * This module defines all API endpoint URLs and configuration for interacting with the FreeSchema backend.
+ * It provides centralized URL management and allows dynamic base URL configuration for different environments.
+ *
+ * @module Constants/ApiConstants
+ * @see https://documentation.freeschema.com for API reference
+ */
+/**
+ * Default configuration object for the API base URL.
+ * Points to the development environment of FreeSchema.
+ *
+ * @example
+ * ```typescript
+ * console.log(config.BASE_URL); // "https://devboom.freeschema.com"
+ * ```
+ */
+export declare const config: {
+    BASE_URL: string;
+};
+/**
+ * The current base URL for all API requests.
+ * This value is dynamically retrieved and can be changed using `changeBaseUrl()`.
+ *
+ * @see {@link getBaseUrl}
+ * @see {@link changeBaseUrl}
+ */
+export declare const BASE_URL: string;
+/**
+ * API endpoint URL for retrieving a single concept by ID.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetConceptUrl}?id=123`);
+ * ```
+ *
+ * @see https://documentation.freeschema.com for API documentation
+ */
+export declare const GetConceptUrl: string;
+/**
+ * API endpoint URL for retrieving multiple concepts in bulk.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(GetConceptBulkUrl, {
+ *   method: 'POST',
+ *   body: JSON.stringify({ ids: [1, 2, 3] })
+ * });
+ * ```
+ */
+export declare const GetConceptBulkUrl: string;
+/**
+ * API endpoint URL for retrieving all concepts belonging to a specific user.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetAllConceptsOfUserUrl}?userId=456`);
+ * ```
+ */
+export declare const GetAllConceptsOfUserUrl: string;
+/**
+ * API endpoint URL for retrieving all connections belonging to a specific user.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetAllConnectionsOfUserUrl}?userId=456`);
+ * ```
+ */
+export declare const GetAllConnectionsOfUserUrl: string;
+/**
+ * API endpoint URL for retrieving all connections within a composition.
+ * A composition is a grouping of related concepts and their connections.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetAllConnectionsOfCompositionUrl}?compositionId=789`);
+ * ```
+ */
+export declare const GetAllConnectionsOfCompositionUrl: string;
+/**
+ * API endpoint URL for retrieving connections of multiple compositions in bulk.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(GetAllConnectionsOfCompositionBulkUrl, {
+ *   method: 'POST',
+ *   body: JSON.stringify({ compositionIds: [1, 2, 3] })
+ * });
+ * ```
+ */
+export declare const GetAllConnectionsOfCompositionBulkUrl: string;
+/**
+ * API endpoint URL for retrieving a concept by its character value.
+ * Character value is the string representation/label of a concept.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetConceptByCharacterValueUrl}?value=hello`);
+ * ```
+ */
+export declare const GetConceptByCharacterValueUrl: string;
+/**
+ * API endpoint URL for retrieving a concept by both its character value and type.
+ * This provides more specific filtering when multiple concepts share the same character value.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetConceptByCharacterAndTypeUrl}?value=hello&typeId=5`);
+ * ```
+ */
+export declare const GetConceptByCharacterAndTypeUrl: string;
+/**
+ * API endpoint URL for retrieving character data by character string.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetCharacterByCharacterUrl}?character=A`);
+ * ```
+ */
+export declare const GetCharacterByCharacterUrl: string;
+/**
+ * API endpoint URL for retrieving all concepts of a specific type.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetAllConceptsByTypeUrl}?typeId=10`);
+ * ```
+ */
+export declare const GetAllConceptsByTypeUrl: string;
+/**
+ * API endpoint URL for retrieving all connections associated with a specific concept.
+ * This includes both incoming and outgoing connections.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(`${GetAllConnectionsOfConceptUrl}?conceptId=123`);
+ * ```
+ */
+export declare const GetAllConnectionsOfConceptUrl: string;
+/**
+ * API endpoint URL for retrieving AI-ranked data.
+ * Can be overridden via the AI_URL environment variable.
+ *
+ * @remarks
+ * The default query parameter `inpage=500` limits the number of results returned.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(GetAllAiData);
+ * ```
+ */
+export declare const GetAllAiData: string;
+/**
+ * API endpoint URL for retrieving reserved IDs from the system.
+ * Reserved IDs are pre-allocated concept IDs used for system-level concepts.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(GetReservedIdUrl);
+ * ```
+ *
+ * @see https://documentation.freeschema.com for information about reserved IDs
+ */
+export declare const GetReservedIdUrl: string;
+/**
+ * API endpoint URL for creating text data in the system.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(CreateTheTextDataUrl, {
+ *   method: 'POST',
+ *   body: JSON.stringify({ text: 'Hello World' })
+ * });
+ * ```
+ */
+export declare const CreateTheTextDataUrl: string;
+/**
+ * API endpoint URL for creating character data in the system.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(CreateTheCharacterDataUrl, {
+ *   method: 'POST',
+ *   body: JSON.stringify({ character: 'A' })
+ * });
+ * ```
+ */
+export declare const CreateTheCharacterDataUrl: string;
+/**
+ * API endpoint URL for creating a new concept in the system.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(CreateTheConceptUrl, {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     characterValue: 'example',
+ *     typeId: 5,
+ *     userId: 123
+ *   })
+ * });
+ * ```
+ */
+export declare const CreateTheConceptUrl: string;
+/**
+ * API endpoint URL for creating a new connection between concepts.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch(CreateTheConnectionUrl, {
+ *   method: 'POST',
+ *   body: JSON.stringify({
+ *     ofTheConceptId: 1,
+ *     toTheConceptId: 2,
+ *     typeId: 3
+ *   })
+ * });
+ * ```
+ */
+export declare const CreateTheConnectionUrl: string;
+/**
+ * Changes the base URL for all API endpoints.
+ * This is useful for switching between development, staging, and production environments.
+ *
+ * @param url - The new base URL to use for API requests
+ *
+ * @example
+ * ```typescript
+ * changeBaseUrl('https://production.freeschema.com');
+ * ```
+ *
+ * @remarks
+ * This function modifies the global BaseUrl object, affecting all subsequent API calls.
+ * Make sure to call this before making any API requests if you need a custom URL.
+ */
+export declare function changeBaseUrl(url: string): void;
+/**
+ * Retrieves the current base URL being used for API requests.
+ *
+ * @returns The current base URL string
+ *
+ * @example
+ * ```typescript
+ * const currentUrl = getBaseUrl();
+ * console.log(currentUrl); // "https://devboom.freeschema.com"
+ * ```
+ */
+export declare function getBaseUrl(): string;

package/dist/types/Constants/FormatConstants.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Format Constants Module for Concept Connection System (CCS-JS)
+ *
+ * This module defines constants for different data format types used throughout the system.
+ * These format types determine how data structures (concepts, connections, etc.) are serialized
+ * and presented when retrieved from the API or displayed in the application.
+ *
+ * @module Constants/FormatConstants
+ * @see https://documentation.freeschema.com for format specifications
+ */
+/**
+ * Standard normal format for data representation.
+ * This format includes essential data fields without additional metadata.
+ *
+ * @example
+ * ```typescript
+ * import { NORMAL } from './FormatConstants';
+ * const format = NORMAL; // 1
+ * ```
+ */
+export declare const NORMAL = 1;
+/**
+ * Data with ID format.
+ * This format includes the data along with its unique identifier.
+ *
+ * @example
+ * ```typescript
+ * import { DATAID } from './FormatConstants';
+ * const format = DATAID; // 2
+ * ```
+ */
+export declare const DATAID = 2;
+/**
+ * Just data format without any metadata.
+ * This format returns only the core data fields, excluding IDs and timestamps.
+ *
+ * @example
+ * ```typescript
+ * import { JUSTDATA } from './FormatConstants';
+ * const format = JUSTDATA; // 3
+ * ```
+ */
+export declare const JUSTDATA = 3;
+/**
+ * Data with ID and date format.
+ * This format includes the data, its ID, and associated timestamp information.
+ *
+ * @example
+ * ```typescript
+ * import { DATAIDDATE } from './FormatConstants';
+ * const format = DATAIDDATE; // 4
+ * ```
+ */
+export declare const DATAIDDATE = 4;
+/**
+ * Raw data format.
+ * This format returns data in its raw form as stored in the database without any processing.
+ *
+ * @example
+ * ```typescript
+ * import { RAW } from './FormatConstants';
+ * const format = RAW; // 5
+ * ```
+ */
+export declare const RAW = 5;
+/**
+ * All IDs format.
+ * This format includes all related IDs (concept IDs, type IDs, user IDs, etc.).
+ *
+ * @example
+ * ```typescript
+ * import { ALLID } from './FormatConstants';
+ * const format = ALLID; // 6
+ * ```
+ */
+export declare const ALLID = 6;
+/**
+ * List normal format.
+ * This format is used for representing lists or arrays of data in standard format.
+ *
+ * @example
+ * ```typescript
+ * import { LISTNORMAL } from './FormatConstants';
+ * const format = LISTNORMAL; // 7
+ * ```
+ */
+export declare const LISTNORMAL = 7;