mftsccs-node 0.0.77 → 0.0.79-dev

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

@@ -8,35 +8,6 @@
 import { Concept } from "../DataStructures/Concept";
 /**
  * Retrieves or creates a type concept based on a string identifier.
- * Type concepts are special concepts that define categories for other concepts in the system.
- *
- * This function first attempts to find an existing type concept locally, then queries the backend
- * if not found. If the concept doesn't exist in the backend, it creates a new type concept.
- * The function uses caching to prevent duplicate requests for the same type.
- *
- * @param type - The string identifier for the type concept (e.g., "the_person", "the_location")
- * @param userId - The user ID associated with the request
- * @returns A promise that resolves to the Concept object representing the type
- *
- * @example
- * ```typescript
- * // Get or create a "person" type concept
- * const personType = await MakeTheTypeConceptApi('the_person', 123);
- * console.log('Person type ID:', personType.id);
- *
- * // Use the type concept when creating new concepts
- * const newPerson = await CreateConcept('John Doe', personType.id);
- * ```
- *
- * @remarks
- * - Uses local caching to prevent duplicate simultaneous requests
- * - First searches for existing concept via GetConceptByCharacterAndCategory
- * - Creates new type concept in backend if not found or if typeId is 4 (unknown type)
- * - Automatically adds the retrieved concept to ConceptsData for local access
- * - Cache entries are cleaned up after the fetch completes
- * - Returns a default concept with id=0 if errors occur
- *
- * @see GetConceptByCharacterAndCategory for local concept searching
- * @see MakeTheNameInBackend for creating named concepts
+ * Type concepts define categories and classifications used in the Concept Connection System.
  */
 export declare function MakeTheTypeConceptApi(type: string, userId: number): Promise<Concept>;

package/dist/types/DataStructures/AccessControl/AccessControlModels.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Data models for V1 Access Control Service
+ * These models mirror the C# FreeSchema.Models.AccessControl types
+ */
+/**
+ * Permission set enum (bitwise flags)
+ * Mirrors C# PermissionSet enum
+ */
+export declare enum PermissionSet {
+    None = 0,
+    Read = 1,// 1
+    Write = 2,// 2
+    Execute = 4,// 4
+    Delete = 8
+}
+/**
+ * Request model for single access operations (check, assign, revoke)
+ */
+export interface AccessRequest {
+    accessId?: number | null;
+    permission: string;
+    entityId?: number | null;
+}
+/**
+ * Result model for access operations
+ */
+export interface AccessResult {
+    accessId: number;
+    permission: string;
+    entityId?: number | null;
+    hasAccess: boolean;
+}
+/**
+ * Target for bulk access operations
+ */
+export interface BulkAccessTarget {
+    entityId?: number | null;
+    permissions: string[];
+}
+/**
+ * Request model for bulk access operations
+ */
+export interface BulkAccessRequest {
+    accessId?: number | null;
+    targets: BulkAccessTarget[];
+}
+/**
+ * Request model for bulk check access operations
+ * Mirrors C# BulkCheckAccessRequest
+ */
+export interface BulkCheckAccessRequest {
+    accessIds: number[];
+    permission: string;
+    entityId?: number | null;
+}
+/**
+ * Request model for access inheritance operations
+ */
+export interface AccessInheritanceRequest {
+    accessId?: number | null;
+    connectionTypeId?: number;
+    enable?: boolean;
+}
+/**
+ * Request model for super admin operations
+ */
+export interface SuperAdminRequest {
+    accessId?: number | null;
+}
+/**
+ * Request model for parent access inheritance operations
+ * Mirrors C# ParentAccessInheritanceRequest
+ */
+export interface ParentAccessInheritanceRequest {
+    parentAccessId: number;
+    childAccessId?: number | null;
+}
+export interface ParentAccessInheritanceWithConceptRequest {
+    parentConceptId: number;
+    childConceptId?: number | null;
+}
+export interface BulkParentAccessInheritanceWithConceptRequest {
+    parentConceptId: number;
+    childConceptIds: number[];
+}
+export interface BulkParentAccessInheritanceResult {
+    childConceptId: number;
+    accessId: number;
+    success: boolean;
+    message?: string;
+}
+export interface SuperAdminWithConceptRequest {
+    conceptId: number;
+}
+export interface AccessInheritanceWithConceptRequest {
+    conceptId: number;
+    connectionTypeId?: number;
+    enable?: boolean;
+}
+/**
+ * Standard API response wrapper for access control endpoints
+ */
+export interface AccessControlAPIResponse<T = unknown> {
+    status: boolean;
+    message?: string;
+    data?: T;
+}
+/**
+ * Valid permissions for validation
+ */
+export declare const VALID_PERMISSIONS: Set<string>;
+/**
+ * Check if a permission string is valid
+ */
+export declare function isValidPermission(permission: string): boolean;
+/**
+ * Request model for adding access by entity
+ * Mirrors C# AddAccessByEntityRequest
+ */
+export interface AddAccessByEntityRequest {
+    conceptId: number;
+    access: string;
+    entityId: number;
+    makePublic: boolean;
+    nestedAccessLevel: number;
+}
+/**
+ * Request model for adding public access to concept
+ * Mirrors C# AddPublicAccessToConcept
+ */
+export interface AddPublicAccessToConcept {
+    conceptId: number;
+    conceptIdList: number[];
+    accessList: string[];
+    nestedAccessLevel: number;
+}
+/**
+ * Request model for bulk adding access by entity
+ * Mirrors C# AddAccessByEntityBulkRequest
+ */
+export interface AddAccessByEntityBulkRequest {
+    conceptId: number;
+    conceptIdList: number[];
+    entityIdList: number[];
+    accessList: string[];
+    nestedAccessLevel: number;
+}
+/**
+ * Request model for adding access by user
+ * Mirrors C# AddAccessByUserRequest
+ */
+export interface AddAccessByUserRequest {
+    conceptId: number;
+    access: string;
+    userId: number;
+    makePublic: boolean;
+}
+/**
+ * Request model for checking bulk access
+ * Mirrors C# CheckAccessBulk
+ */
+export interface CheckAccessBulk {
+    userId: number;
+    access: string;
+    conceptIdList: number[];
+    connectionIdList: number[];
+}
+/**
+ * Alternative API response format
+ * Mirrors C# AccessControlApiResponse
+ */
+export interface AccessControlApiResponse {
+    success?: boolean | null;
+    data?: unknown;
+    message?: string | null;
+}

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

@@ -43,6 +43,7 @@ export declare class BaseUrl {
     static setNodeCacheUrl(cacheServerUrl?: string): void;
     static setCacheServers(cacheServers?: string[]): void;
     static GetReadBaseUrl(): string;
+    static GetNodeBaseUrl(): string;
     static GetReadBaseUrlCandidates(): string[];
     /**
      * Returns the URL for retrieving a single concept by ID.
@@ -254,6 +255,7 @@ export declare class BaseUrl {
      * @returns {string} The type concept creation API endpoint
      */
     static MakeTheTypeConceptUrl(): string;
+    static CreateTypeConceptUrl(): string;
     /**
      * Returns the URL for deleting a single connection.
      * @returns {string} The connection deletion API endpoint

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

@@ -40,6 +40,13 @@
  * await init("https://api.example.com", "", "MyApp", config);
  * ```
  */
+type CCSConfigOptions = Partial<Omit<CCSConfig, "cacheServers">> & {
+    cacheServers?: string[] | string;
+    cacheServerUrl?: string;
+    cacheServer?: string;
+    cache_servers?: string[] | string;
+};
+export declare function normalizeCacheServers(cacheServers?: string[] | string): any[];
 export declare class CCSConfig {
     /** URL for the AI service. Defaults to "https://ai.freeschema.com" */
     aiUrl: string;
@@ -51,6 +58,10 @@ export declare class CCSConfig {
     accessToken: string;
     /** Whether to enable AI features. Defaults to true */
     enableAi: boolean;
+    /** Whether to enable access control checks. Defaults to false (allow all access). */
+    enableAccessControl: boolean;
+    /** Base URL for Access Control API. Falls back to env/default when not provided. */
+    accessControlBaseUrl?: string;
     /**
      * Dictionary of feature flags for controlling CCS behavior.
      * Available flags:
@@ -90,6 +101,8 @@ export declare class CCSConfig {
      * const config = new CCSConfig({
      *     aiUrl: "https://custom-ai.example.com",
      *     enableAi: false,
+    *     enableAccessControl: true,
+    *     accessControlBaseUrl: "https://access.example.com/api/access-control",
      *     clientId: "123456",
      *     clientSecret: "secret",
      *     flags: {
@@ -99,7 +112,7 @@ export declare class CCSConfig {
      * });
      * ```
      */
-    constructor(options?: Partial<CCSConfig>);
+    constructor(options?: CCSConfigOptions);
     /**
      * Returns true if OAuth credentials are configured.
      * @returns {boolean} Whether both clientId and clientSecret are set
@@ -171,3 +184,4 @@ export declare class CCSConfig {
      */
     setParameter(paramName: string, value: string): void;
 }
+export {};

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

@@ -214,6 +214,7 @@ export declare class Transaction {
    * ```
    */
     MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<Concept>;
+    CreateTypeConcept(typeConcept: Concept | number, characterValue: string, userId?: number, accessId?: number, sessionInformationId?: number): Promise<Concept>;
     /**
    * Creates a connection between two concepts within the transaction.
    * Establishes a typed relationship between source and target concepts.

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

@@ -0,0 +1,162 @@
+/**
+ * APIClientService
+ *
+ * API client service for Access Control endpoints.
+ * Provides typed HTTP methods for all access control API operations.
+ *
+ * This is the TypeScript equivalent of the C# APIClientService class.
+ */
+import { AccessRequest, AccessResult, AccessControlAPIResponse, BulkAccessRequest, BulkCheckAccessRequest, AccessInheritanceRequest, SuperAdminRequest, ParentAccessInheritanceRequest, ParentAccessInheritanceWithConceptRequest, BulkParentAccessInheritanceWithConceptRequest, BulkParentAccessInheritanceResult, SuperAdminWithConceptRequest, AccessInheritanceWithConceptRequest } from '../../DataStructures/AccessControl/AccessControlModels';
+export interface IAPIClientService {
+    assignAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    checkAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    revokeAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    assignAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    revokeAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    checkAccessBulkAsync(request: BulkCheckAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    getAccessByIdAsync(accessId: number): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    setAccessInheritanceAsync(request: AccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    getAccessInheritanceStatusAsync(accessId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+    assignSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    revokeSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    checkSuperAdminStatusAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    setParentAccessInheritanceAsync(request: ParentAccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    removeParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    hasParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    getParentAccessIdAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    setParentAccessInheritanceByConceptAsync(request: ParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    setParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    removeParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    removeParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    hasParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    getParentAccessIdByConceptAsync(childConceptId: number): Promise<AccessControlAPIResponse>;
+    assignSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    revokeSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    checkSuperAdminByConceptAsync(conceptId: number): Promise<AccessControlAPIResponse>;
+    setAccessInheritanceByConceptAsync(request: AccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    getAccessInheritanceStatusByConceptAsync(conceptId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+}
+export declare class APIClientService implements IAPIClientService {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Perform a GET request and return typed response
+     */
+    private getAsync;
+    /**
+     * Perform a POST request with JSON body and return typed response
+     */
+    private postAsync;
+    /**
+     * Perform a DELETE request with optional JSON body and return typed response
+     */
+    private deleteAsync;
+    /**
+     * Assign access to an entity
+     */
+    assignAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Check if an entity has access
+     */
+    checkAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Revoke access from an entity
+     */
+    revokeAccessAsync(request: AccessRequest): Promise<AccessControlAPIResponse<AccessResult>>;
+    /**
+     * Assign access to multiple targets in bulk
+     */
+    assignAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Revoke access from multiple targets in bulk
+     */
+    revokeAccessBulkAsync(request: BulkAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Check access for multiple targets in bulk
+     */
+    checkAccessBulkAsync(request: BulkCheckAccessRequest): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Get all access entries for a specific accessId
+     */
+    getAccessByIdAsync(accessId: number): Promise<AccessControlAPIResponse<AccessResult[]>>;
+    /**
+     * Set access inheritance for an access ID
+     */
+    setAccessInheritanceAsync(request: AccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Get access inheritance status
+     */
+    getAccessInheritanceStatusAsync(accessId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Assign super admin access
+     */
+    assignSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Revoke super admin access
+     */
+    revokeSuperAdminAccessAsync(request: SuperAdminRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Check super admin status
+     */
+    checkSuperAdminStatusAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Set parent access inheritance link
+     */
+    setParentAccessInheritanceAsync(request: ParentAccessInheritanceRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Remove parent access inheritance link
+     */
+    removeParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Check if parent access inheritance link exists
+     */
+    hasParentAccessInheritanceAsync(accessId: number, parentAccessId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Get the parent access ID for a given access ID
+     */
+    getParentAccessIdAsync(accessId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Set parent access inheritance by concept IDs (server resolves conceptId → accessId)
+     */
+    setParentAccessInheritanceByConceptAsync(request: ParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Set parent access inheritance for multiple children with one parent (concept-based)
+     */
+    setParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    /**
+     * Remove parent access inheritance by concept IDs
+     */
+    removeParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Remove parent access inheritance for multiple children (concept-based)
+     */
+    removeParentAccessInheritanceBulkByConceptAsync(request: BulkParentAccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse<BulkParentAccessInheritanceResult[]>>;
+    /**
+     * Check if parent access inheritance exists by concept IDs
+     */
+    hasParentAccessInheritanceByConceptAsync(childConceptId: number, parentConceptId?: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Get the parent access ID by child concept ID
+     */
+    getParentAccessIdByConceptAsync(childConceptId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Assign super admin by concept ID
+     */
+    assignSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Revoke super admin by concept ID
+     */
+    revokeSuperAdminByConceptAsync(request: SuperAdminWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Check super admin status by concept ID
+     */
+    checkSuperAdminByConceptAsync(conceptId: number): Promise<AccessControlAPIResponse>;
+    /**
+     * Set access inheritance by concept ID
+     */
+    setAccessInheritanceByConceptAsync(request: AccessInheritanceWithConceptRequest): Promise<AccessControlAPIResponse>;
+    /**
+     * Get access inheritance status by concept ID
+     */
+    getAccessInheritanceStatusByConceptAsync(conceptId: number, connectionTypeId?: number): Promise<AccessControlAPIResponse>;
+}

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

@@ -1,19 +1,77 @@
-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[]>;
+/**
+ * CacheService
+ *
+ * Thread-safe in-memory cache for access checks with TTL-based expiration.
+ * Supports single and bulk queries with secondary indexes.
+ * Key format: "{accessId}:{permission}:{entityId}"
+ * Value: CacheEntry { value: boolean, expiresAt: number }
+ *
+ * This is the TypeScript equivalent of the C# CacheService class.
+ */
+export interface ICacheService {
+    get(accessId: number, permission: string, entityId?: number | null): boolean | null;
+    set(accessId: number, permission: string, entityId: number | null | undefined, hasAccess: boolean): void;
+    remove(accessId: number, permission: string, entityId?: number | null): void;
+    clear(): void;
+    getPermissionsByAccessAndEntity(accessId: number, entityId?: number | null): Map<string, boolean>;
+    getPermissionsByAccess(accessId: number): Map<string, boolean>;
+    getPermissionsByEntity(entityId: number): Map<string, boolean>;
+    getSuperAdmin(entityId: number): boolean | null;
+    setSuperAdmin(entityId: number, isSuperAdmin: boolean): void;
+    clearSuperAdminCache(): void;
+}
+export declare class CacheService implements ICacheService {
+    private readonly accessCache;
+    private readonly accessIndex;
+    private readonly entityIndex;
+    private static readonly superAdminCache;
+    private setCounter;
+    /**
+     * Generate a cache key from accessId, permission, and entityId
+     */
+    private generateKey;
+    /**
+     * Get cached access. Returns true/false if present and not expired, null if not cached or expired.
+     */
+    get(accessId: number, permission: string, entityId?: number | null): boolean | null;
+    /**
+     * Set or update cached access with TTL
+     */
+    set(accessId: number, permission: string, entityId: number | null | undefined, hasAccess: boolean): void;
+    /**
+     * Remove a cached entry (e.g., after revoke)
+     */
+    remove(accessId: number, permission: string, entityId?: number | null): void;
+    /**
+     * Clear all cached access entries
+     */
+    clear(): void;
+    /**
+     * Sweep all expired entries from access cache, indexes, and super admin cache
+     */
+    private sweepExpired;
+    /**
+     * Get all permissions for a specific accessId + entityId (excludes expired entries)
+     */
+    getPermissionsByAccessAndEntity(accessId: number, entityId?: number | null): Map<string, boolean>;
+    /**
+     * Get all permissions for a specific accessId across all entities (excludes expired entries)
+     */
+    getPermissionsByAccess(accessId: number): Map<string, boolean>;
+    /**
+     * Get all permissions for a specific entity across all accessIds (excludes expired entries)
+     */
+    getPermissionsByEntity(entityId: number): Map<string, boolean>;
+    /**
+     * Get cached super admin status for an entity (returns null if expired or not cached)
+     */
+    getSuperAdmin(entityId: number): boolean | null;
+    /**
+     * Set super admin status for an entity with TTL
+     */
+    setSuperAdmin(entityId: number, isSuperAdmin: boolean): void;
+    /**
+     * Clear the super admin cache
+     */
+    clearSuperAdminCache(): void;
 }