mftsccs-node 0.0.78-dev → 0.0.80-dev

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.

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

@@ -46,6 +46,7 @@ type CCSConfigOptions = Partial<Omit<CCSConfig, "cacheServers">> & {
     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;
@@ -57,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:
@@ -96,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: {

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

@@ -171,12 +171,15 @@ export declare class Transaction {
      */
     DeleteConnectionsBetween(query: Partial<FetchConnectionQuery>): Promise<number[]>;
     /**
-     * Queues connections matching multiple queries for deletion on commit.
+     * Queues connections matching multiple queries for deletion on commit, plus
+     * any already-known connection IDs passed directly.
      *
-     * The queries are resolved in one API call, then their connection IDs are
-     * merged into this transaction's pending deletion queue.
+     * The queries (if any) are resolved in one API call; their connection IDs
+     * are merged with `knownConnectionIds` into this transaction's pending
+     * deletion queue. Pass an empty `queries` array to queue only IDs you
+     * already have, with no extra lookup call.
      */
-    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[]): Promise<number[]>;
+    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[], knownConnectionIds?: number[]): Promise<number[]>;
     /**
    * Creates a new instance concept within the transaction.
    * The concept represents a data instance of a specified type with associated metadata.
@@ -214,7 +217,6 @@ export declare class Transaction {
    * ```
    */
     MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<Concept>;
-    CreateReferentConcept(type: string, referentConcept: Concept | number, characterValue?: string, userId?: number, accessId?: number, sessionInformationId?: 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.

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;
 }