fiberx-backend-toolkit 1.0.7 → 1.0.8

package/dist/fibase/app_event_payload_builder.d.ts

@@ -0,0 +1,8 @@
+import { FibaseAppEventBuildInputInterface, FibaseAppEventEnvelopeInterface } from "../types/fibase_type";
+declare class FibaseAppEventPayloadBuilder {
+    /**
+     * Build the shared app-event envelope expected by the Fibase central app intake endpoint.
+     */
+    static build<TPayload>(input: FibaseAppEventBuildInputInterface<TPayload>): FibaseAppEventEnvelopeInterface<TPayload>;
+}
+export default FibaseAppEventPayloadBuilder;

package/dist/fibase/app_event_payload_builder.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const main_1 = require("../utils/main");
+class FibaseAppEventPayloadBuilder {
+    /**
+     * Build the shared app-event envelope expected by the Fibase central app intake endpoint.
+     */
+    static build(input) {
+        const occurred_at = input.occurred_at
+            ? new Date(input.occurred_at).toISOString()
+            : new Date().toISOString();
+        const source_event_id = input.source_event_id ?? main_1.UUIDGeneratorUtil.generateUUIDV2("EVT");
+        return {
+            event_type: input.event_type.trim().toLowerCase(),
+            event_version: input.event_version?.trim().toLowerCase() ?? "v1",
+            source_event_id,
+            idempotency_key: input.idempotency_key ?? source_event_id,
+            correlation_id: input.correlation_id ?? null,
+            occurred_at,
+            payload: input.payload,
+            metadata: input.metadata ?? null,
+        };
+    }
+}
+exports.default = FibaseAppEventPayloadBuilder;

package/dist/fibase/fibase_app_client.d.ts

@@ -0,0 +1,52 @@
+import { FibaseAppClientConfigInterface, FibaseAppClientEnvOptionsInterface, FibaseAppEventBuildInputInterface, FibaseHttpResponseInterface, FibaseRequestOptionsInterface, FibaseSendAppEventOptionsInterface, FibaseSignedRequestDataInterface, FibaseSignedRequestInputInterface } from "../types/fibase_type";
+declare class FibaseAppClient {
+    private static instance;
+    readonly name = "fibase_app_client";
+    private readonly logger;
+    private readonly config;
+    private readonly headers;
+    private static readonly DEFAULT_HEADERS;
+    private static readonly DEFAULT_BASE_URLS;
+    constructor(config: FibaseAppClientConfigInterface);
+    /**
+     * Create a singleton client for applications that prefer process-wide reuse.
+     */
+    static initialize(config: FibaseAppClientConfigInterface): FibaseAppClient;
+    /**
+     * Return the initialized singleton client.
+     */
+    static getInstance(): FibaseAppClient;
+    /**
+     * Build a client from environment variables loaded by EnvManagerUtil.
+     */
+    static fromEnv(options?: FibaseAppClientEnvOptionsInterface): FibaseAppClient;
+    /**
+     * Validate the minimum data required to sign Fibase app requests.
+     */
+    private validateConfig;
+    /**
+     * Normalize request paths so signature generation matches the server authenticator.
+     */
+    private normalizePath;
+    /**
+     * Build the same body hash format used by Fibase's RequestAuthenticatorUtil.
+     */
+    hashBody(body: unknown): string;
+    /**
+     * Build the canonical string signed by external apps and verified by Fibase.
+     */
+    buildCanonicalString(method: string, path: string, timestamp: string, nonce: string, body: unknown): string;
+    /**
+     * Build a signed request without sending it. Useful for tests and custom transports.
+     */
+    buildSignedRequest<TBody = unknown>(input: FibaseSignedRequestInputInterface<TBody>): FibaseSignedRequestDataInterface<TBody>;
+    /**
+     * Send a signed request to Fibase using the standard app-auth headers.
+     */
+    request<TResponse = unknown, TBody = unknown>(method: string, path: string, body?: TBody, options?: FibaseRequestOptionsInterface): Promise<FibaseHttpResponseInterface<TResponse>>;
+    /**
+     * Build and send a standard app event to the Fibase central app.
+     */
+    sendAppEvent<TPayload, TResponse = unknown>(input: FibaseAppEventBuildInputInterface<TPayload>, options?: FibaseSendAppEventOptionsInterface): Promise<FibaseHttpResponseInterface<TResponse>>;
+}
+export default FibaseAppClient;

package/dist/fibase/fibase_app_client.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const main_1 = require("../utils/main");
+const app_event_payload_builder_1 = __importDefault(require("./app_event_payload_builder"));
+class FibaseAppClient {
+    static instance = null;
+    name = "fibase_app_client";
+    logger = new main_1.LoggerUtil(this.name);
+    config;
+    headers;
+    static DEFAULT_HEADERS = {
+        app_id: "X-App-Id",
+        app_key_version: "X-Key-Version",
+        timestamp: "X-Timestamp",
+        nonce: "X-Nonce",
+        signature: "x-Signature",
+        request_id: "X-Request-Id",
+        content_type: "Content-Type",
+    };
+    static DEFAULT_BASE_URLS = {
+        development: "http://localhost:4000",
+        staging: "https://staging-api.fibase.app",
+        production: "https://api.fibase.app",
+    };
+    constructor(config) {
+        this.config = {
+            ...config,
+            base_url: config.base_url.replace(/\/+$/, ""),
+            key_algorithm: config.key_algorithm ?? "sha256",
+            timeout_ms: config.timeout_ms ?? 30000,
+        };
+        this.headers = { ...FibaseAppClient.DEFAULT_HEADERS, ...(config.headers ?? {}) };
+        this.validateConfig();
+    }
+    /**
+     * Create a singleton client for applications that prefer process-wide reuse.
+     */
+    static initialize(config) {
+        if (this.instance) {
+            throw new Error("FibaseAppClient already initialized.");
+        }
+        this.instance = new FibaseAppClient(config);
+        return this.instance;
+    }
+    /**
+     * Return the initialized singleton client.
+     */
+    static getInstance() {
+        if (!this.instance) {
+            throw new Error("FibaseAppClient not initialized.");
+        }
+        return this.instance;
+    }
+    /**
+     * Build a client from environment variables loaded by EnvManagerUtil.
+     */
+    static fromEnv(options = {}) {
+        const env_manager = main_1.EnvManagerUtil.getInstance();
+        const mode = env_manager.getEnvVar("MODE", "development") ?? "development";
+        const default_base_urls = {
+            ...FibaseAppClient.DEFAULT_BASE_URLS,
+            ...(options.default_base_urls ?? {}),
+        };
+        const base_url = env_manager.getEnvVar(options.base_url_key ?? "FIBASE_BASE_URL") ??
+            default_base_urls[mode] ??
+            default_base_urls.development ??
+            FibaseAppClient.DEFAULT_BASE_URLS.development;
+        const app_id = env_manager.getEnvVar(options.app_id_key ?? "FIBASE_APP_ID");
+        const app_private_key = env_manager.getEnvVar(options.app_private_key_key ?? "FIBASE_APP_PRIVATE_KEY");
+        if (!app_id || !app_private_key) {
+            throw new Error("FIBASE_APP_ID and FIBASE_APP_PRIVATE_KEY are required");
+        }
+        return new FibaseAppClient({
+            base_url,
+            app_id,
+            app_private_key,
+            app_key_version: env_manager.getEnvVar(options.app_key_version_key ?? "FIBASE_APP_KEY_VERSION", 1),
+            key_algorithm: env_manager.getEnvVar(options.key_algorithm_key ?? "FIBASE_APP_KEY_ALGORITHM", "sha256"),
+            timeout_ms: Number(env_manager.getEnvVar(options.timeout_ms_key ?? "FIBASE_TIMEOUT_MS", 30000)),
+        });
+    }
+    /**
+     * Validate the minimum data required to sign Fibase app requests.
+     */
+    validateConfig() {
+        if (!this.config.base_url) {
+            throw new Error("Fibase base_url is required");
+        }
+        if (!this.config.app_id) {
+            throw new Error("Fibase app_id is required");
+        }
+        if (!this.config.app_private_key) {
+            throw new Error("Fibase app_private_key is required");
+        }
+    }
+    /**
+     * Normalize request paths so signature generation matches the server authenticator.
+     */
+    normalizePath(path) {
+        const [pathname] = path.split("?");
+        return pathname.startsWith("/") ? pathname : `/${pathname}`;
+    }
+    /**
+     * Build the same body hash format used by Fibase's RequestAuthenticatorUtil.
+     */
+    hashBody(body) {
+        const json = JSON.stringify(body ?? {});
+        return main_1.CryptoKeyUtil.hash(json, "sha256", "hex");
+    }
+    /**
+     * Build the canonical string signed by external apps and verified by Fibase.
+     */
+    buildCanonicalString(method, path, timestamp, nonce, body) {
+        return [
+            method.toUpperCase(),
+            this.normalizePath(path),
+            timestamp,
+            nonce,
+            this.hashBody(body),
+        ].join("\n");
+    }
+    /**
+     * Build a signed request without sending it. Useful for tests and custom transports.
+     */
+    buildSignedRequest(input) {
+        const method = input.method.toUpperCase();
+        const path = this.normalizePath(input.path);
+        const body = (input.body ?? {});
+        const timestamp = input.timestamp ?? Date.now().toString();
+        const nonce = input.nonce ?? main_1.UUIDGeneratorUtil.generateUUIDV2("NONCE");
+        const canonical = this.buildCanonicalString(method, path, timestamp, nonce, body);
+        const signature = main_1.CryptoKeyUtil.sign(canonical, this.config.app_private_key, this.config.key_algorithm, "base64");
+        return {
+            url: `${this.config.base_url}${path}`,
+            method,
+            path,
+            body,
+            canonical,
+            signature,
+            headers: {
+                [this.headers.content_type]: "application/json",
+                [this.headers.app_id]: this.config.app_id,
+                [this.headers.app_key_version]: String(this.config.app_key_version ?? 1),
+                [this.headers.timestamp]: timestamp,
+                [this.headers.nonce]: nonce,
+                [this.headers.signature]: signature,
+                [this.headers.request_id]: input.request_id ?? main_1.UUIDGeneratorUtil.generateUUIDV2("REQ"),
+            },
+        };
+    }
+    /**
+     * Send a signed request to Fibase using the standard app-auth headers.
+     */
+    async request(method, path, body, options = {}) {
+        const signed_request = this.buildSignedRequest({
+            method,
+            path,
+            body,
+            request_id: options.request_id,
+        });
+        const request_config = {
+            url: signed_request.url,
+            method: signed_request.method,
+            data: signed_request.body,
+            headers: { ...signed_request.headers, ...(options.headers ?? {}) },
+            timeout: this.config.timeout_ms,
+        };
+        this.logger.info("Sending signed Fibase app request", {
+            method: signed_request.method,
+            path: signed_request.path,
+            request_id: signed_request.headers[this.headers.request_id],
+        });
+        const response = await axios_1.default.request(request_config);
+        return {
+            status: response.status,
+            status_text: response.statusText,
+            data: response.data,
+            headers: response.headers,
+        };
+    }
+    /**
+     * Build and send a standard app event to the Fibase central app.
+     */
+    async sendAppEvent(input, options = {}) {
+        const event_payload = app_event_payload_builder_1.default.build(input);
+        return this.request("POST", options.path ?? "/api/app-events", event_payload, options);
+    }
+}
+exports.default = FibaseAppClient;

package/dist/fibase/main.d.ts

@@ -0,0 +1,3 @@
+import FibaseAppEventPayloadBuilder from "./app_event_payload_builder";
+import FibaseAppClient from "./fibase_app_client";
+export { FibaseAppEventPayloadBuilder, FibaseAppClient };

package/dist/fibase/main.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FibaseAppClient = exports.FibaseAppEventPayloadBuilder = void 0;
+const app_event_payload_builder_1 = __importDefault(require("./app_event_payload_builder"));
+exports.FibaseAppEventPayloadBuilder = app_event_payload_builder_1.default;
+const fibase_app_client_1 = __importDefault(require("./fibase_app_client"));
+exports.FibaseAppClient = fibase_app_client_1.default;

package/dist/index.d.ts

@@ -6,3 +6,5 @@ export * from "./validators/main";
 export * from "./storage/main";
 export * from "./mailer/main";
 export * from "./rbac/main";
+export * from "./processors/main";
+export * from "./fibase/main";

package/dist/index.js

@@ -22,3 +22,5 @@ __exportStar(require("./validators/main"), exports);
 __exportStar(require("./storage/main"), exports);
 __exportStar(require("./mailer/main"), exports);
 __exportStar(require("./rbac/main"), exports);
+__exportStar(require("./processors/main"), exports);
+__exportStar(require("./fibase/main"), exports);

package/dist/processors/base_batch_processor.d.ts

@@ -0,0 +1,29 @@
+import { BatchProcessorAdapterInterface, BatchProcessorOptionsInterface, BatchProcessorRecordResultInterface, BatchProcessorRunResultInterface } from "../types/processor_type";
+declare class BaseBatchProcessor<TRecord, TResult> {
+    readonly name: string;
+    private readonly logger;
+    private readonly adapter;
+    private readonly options;
+    constructor(adapter: BatchProcessorAdapterInterface<TRecord, TResult>, options?: BatchProcessorOptionsInterface);
+    /**
+     * Convert a record id to a stable log-safe string.
+     */
+    private getRecordId;
+    /**
+     * Mark a record as failed or dead-lettered, depending on adapter retry policy.
+     */
+    private markFailure;
+    /**
+     * Process one record and update its lifecycle independently of the rest of the batch.
+     */
+    processSingleRecord(record: TRecord): Promise<BatchProcessorRecordResultInterface<TRecord, TResult>>;
+    /**
+     * Process a provided list of records with the configured concurrency limit.
+     */
+    processRecords(records: TRecord[]): Promise<BatchProcessorRecordResultInterface<TRecord, TResult>[]>;
+    /**
+     * Fetch and process the next available batch of records.
+     */
+    run(limit?: number): Promise<BatchProcessorRunResultInterface>;
+}
+export default BaseBatchProcessor;

package/dist/processors/base_batch_processor.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const main_1 = require("../utils/main");
+class BaseBatchProcessor {
+    name;
+    logger;
+    adapter;
+    options;
+    constructor(adapter, options = {}) {
+        this.name = options.name ?? "base_batch_processor";
+        this.logger = new main_1.LoggerUtil(this.name);
+        this.adapter = adapter;
+        this.options = {
+            name: this.name,
+            concurrency: options.concurrency ?? 5,
+            default_limit: options.default_limit ?? 50,
+            continue_on_error: options.continue_on_error ?? true,
+        };
+    }
+    /**
+     * Convert a record id to a stable log-safe string.
+     */
+    getRecordId(record) {
+        return String(this.adapter.getRecordId(record));
+    }
+    /**
+     * Mark a record as failed or dead-lettered, depending on adapter retry policy.
+     */
+    async markFailure(record, error) {
+        const record_id = this.getRecordId(record);
+        const should_dead_letter = (await this.adapter.shouldMoveToDeadLetter?.(record, error)) ?? false;
+        if (should_dead_letter && this.adapter.markRecordAsDeadLetter) {
+            await this.adapter.markRecordAsDeadLetter(record, error);
+            this.logger.error(`Record ${record_id} moved to dead letter`, { record_id, error });
+            return { record, record_id, status: "dead_letter", error };
+        }
+        await this.adapter.markRecordAsFailed(record, error);
+        this.logger.error(`Record ${record_id} failed`, { record_id, error });
+        return { record, record_id, status: "failed", error };
+    }
+    /**
+     * Process one record and update its lifecycle independently of the rest of the batch.
+     */
+    async processSingleRecord(record) {
+        const record_id = this.getRecordId(record);
+        try {
+            this.logger.info(`Processing record ${record_id}`, { record_id });
+            await this.adapter.beforeProcessRecord?.(record);
+            await this.adapter.markRecordAsProcessing?.(record);
+            const result = await this.adapter.processRecord(record);
+            await this.adapter.markRecordAsCompleted(record, result);
+            const completed_result = {
+                record,
+                record_id,
+                status: "completed",
+                result,
+            };
+            await this.adapter.afterProcessRecord?.(record, completed_result);
+            this.logger.success(`Completed record ${record_id}`, { record_id });
+            return completed_result;
+        }
+        catch (error) {
+            const failed_result = await this.markFailure(record, error);
+            await this.adapter.afterProcessRecord?.(record, failed_result);
+            if (!this.options.continue_on_error) {
+                throw error;
+            }
+            return failed_result;
+        }
+    }
+    /**
+     * Process a provided list of records with the configured concurrency limit.
+     */
+    async processRecords(records) {
+        if (!records.length) {
+            return [];
+        }
+        return main_1.PLimitUtil.map(records, this.options.concurrency, async (record) => {
+            return this.processSingleRecord(record);
+        });
+    }
+    /**
+     * Fetch and process the next available batch of records.
+     */
+    async run(limit = this.options.default_limit) {
+        this.logger.info(`Starting batch processor ${this.name}`, {
+            limit,
+            concurrency: this.options.concurrency,
+        });
+        const records = await this.adapter.fetchRecordsToProcess(limit);
+        this.logger.info(`Fetched ${records.length} record(s) for ${this.name}`, {
+            count: records.length,
+        });
+        const results = await this.processRecords(records);
+        const summary = {
+            fetched_count: records.length,
+            processed_count: results.length,
+            succeeded_count: results.filter((result) => result.status === "completed").length,
+            failed_count: results.filter((result) => result.status === "failed").length,
+            dead_letter_count: results.filter((result) => result.status === "dead_letter").length,
+        };
+        this.logger.info(`Completed batch processor ${this.name}`, summary);
+        return summary;
+    }
+}
+exports.default = BaseBatchProcessor;

package/dist/processors/main.d.ts

@@ -0,0 +1,2 @@
+import BaseBatchProcessor from "./base_batch_processor";
+export { BaseBatchProcessor };

package/dist/processors/main.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseBatchProcessor = void 0;
+const base_batch_processor_1 = __importDefault(require("./base_batch_processor"));
+exports.BaseBatchProcessor = base_batch_processor_1.default;

package/dist/types/fibase_type.d.ts

@@ -0,0 +1,78 @@
+export type FibaseEnvironmentType = "development" | "staging" | "production" | string;
+export interface FibaseHeaderNamesInterface {
+    app_id: string;
+    app_key_version: string;
+    timestamp: string;
+    nonce: string;
+    signature: string;
+    request_id: string;
+    content_type: string;
+}
+export interface FibaseAppClientConfigInterface {
+    base_url: string;
+    app_id: string;
+    app_private_key: string;
+    app_key_version?: number | string;
+    key_algorithm?: "sha256" | "sha384" | "sha512";
+    timeout_ms?: number;
+    headers?: Partial<FibaseHeaderNamesInterface>;
+}
+export interface FibaseAppClientEnvOptionsInterface {
+    base_url_key?: string;
+    app_id_key?: string;
+    app_private_key_key?: string;
+    app_key_version_key?: string;
+    key_algorithm_key?: string;
+    timeout_ms_key?: string;
+    default_base_urls?: Partial<Record<FibaseEnvironmentType, string>>;
+}
+export interface FibaseSignedRequestInputInterface<TBody = unknown> {
+    method: string;
+    path: string;
+    body?: TBody;
+    request_id?: string;
+    nonce?: string;
+    timestamp?: string;
+}
+export interface FibaseSignedRequestDataInterface<TBody = unknown> {
+    url: string;
+    method: string;
+    path: string;
+    body: TBody;
+    headers: Record<string, string>;
+    canonical: string;
+    signature: string;
+}
+export interface FibaseRequestOptionsInterface {
+    request_id?: string;
+    headers?: Record<string, string>;
+}
+export interface FibaseAppEventEnvelopeInterface<TPayload = unknown> {
+    event_type: string;
+    event_version: string;
+    source_event_id: string;
+    idempotency_key: string;
+    correlation_id?: string | null;
+    occurred_at: string;
+    payload: TPayload;
+    metadata?: Record<string, unknown> | null;
+}
+export interface FibaseAppEventBuildInputInterface<TPayload = unknown> {
+    event_type: string;
+    payload: TPayload;
+    event_version?: string;
+    source_event_id?: string;
+    idempotency_key?: string;
+    correlation_id?: string | null;
+    occurred_at?: string | Date;
+    metadata?: Record<string, unknown> | null;
+}
+export interface FibaseSendAppEventOptionsInterface extends FibaseRequestOptionsInterface {
+    path?: string;
+}
+export interface FibaseHttpResponseInterface<TData = unknown> {
+    status: number;
+    status_text: string;
+    data: TData;
+    headers: Record<string, unknown>;
+}

package/dist/types/fibase_type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/main.d.ts

@@ -9,3 +9,5 @@ export * from "./rbac_type";
 export * from "./mailer_type";
 export * from "./validator_type";
 export * from "./storage_type";
+export * from "./processor_type";
+export * from "./fibase_type";

package/dist/types/main.js

@@ -25,3 +25,5 @@ __exportStar(require("./rbac_type"), exports);
 __exportStar(require("./mailer_type"), exports);
 __exportStar(require("./validator_type"), exports);
 __exportStar(require("./storage_type"), exports);
+__exportStar(require("./processor_type"), exports);
+__exportStar(require("./fibase_type"), exports);

package/dist/types/processor_type.d.ts

@@ -0,0 +1,32 @@
+export interface BatchProcessorRunResultInterface {
+    fetched_count: number;
+    processed_count: number;
+    succeeded_count: number;
+    failed_count: number;
+    dead_letter_count: number;
+}
+export interface BatchProcessorRecordResultInterface<TRecord, TResult> {
+    record: TRecord;
+    record_id: string;
+    status: "completed" | "failed" | "dead_letter";
+    result?: TResult;
+    error?: unknown;
+}
+export interface BatchProcessorOptionsInterface {
+    name?: string;
+    concurrency?: number;
+    default_limit?: number;
+    continue_on_error?: boolean;
+}
+export interface BatchProcessorAdapterInterface<TRecord, TResult> {
+    fetchRecordsToProcess(limit: number): Promise<TRecord[]>;
+    getRecordId(record: TRecord): string | number;
+    markRecordAsProcessing?(record: TRecord): Promise<TRecord | void>;
+    processRecord(record: TRecord): Promise<TResult>;
+    markRecordAsCompleted(record: TRecord, result: TResult): Promise<TRecord | void>;
+    markRecordAsFailed(record: TRecord, error: unknown): Promise<TRecord | void>;
+    shouldMoveToDeadLetter?(record: TRecord, error: unknown): boolean | Promise<boolean>;
+    markRecordAsDeadLetter?(record: TRecord, error: unknown): Promise<TRecord | void>;
+    beforeProcessRecord?(record: TRecord): Promise<void>;
+    afterProcessRecord?(record: TRecord, result: BatchProcessorRecordResultInterface<TRecord, TResult>): Promise<void>;
+}

package/dist/types/processor_type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fiberx-backend-toolkit",
-    "version": "1.0.7",
+    "version": "1.0.8",
     "description": "A TypeScript backend toolkit providing shared domain logic, infrastructure helpers, and utilities for FiberX server-side applications and services.",
     "type": "commonjs",
     "main": "./dist/index.js",
@@ -51,6 +51,16 @@
             "require": "./dist/mailer/main.js",
             "default": "./dist/mailer/main.js"
         },
+        "./processors": {
+            "types": "./dist/processors/main.d.ts",
+            "require": "./dist/processors/main.js",
+            "default": "./dist/processors/main.js"
+        },
+        "./fibase": {
+            "types": "./dist/fibase/main.d.ts",
+            "require": "./dist/fibase/main.js",
+            "default": "./dist/fibase/main.js"
+        },
         "./rbac": {
             "types": "./dist/rbac/main.d.ts",
             "require": "./dist/rbac/main.js",