libmodulor 0.4.0 → 0.5.0

package/dist/esm/std/impl/OllamaLLMManager.js

@@ -0,0 +1,56 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { IllegalArgumentError } from '../../error/index.js';
+let OllamaLLMManager = class OllamaLLMManager {
+    httpAPICaller;
+    settingsManager;
+    constructor(httpAPICaller, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            oll_base_url: this.settingsManager.get()('oll_base_url'),
+        };
+    }
+    async send(req) {
+        const firstMessage = req.messages[0];
+        if (!firstMessage) {
+            throw new IllegalArgumentError('Please provide at least one message');
+        }
+        return await this.httpAPICaller.exec({
+            errBuilder: async (error) => error.error,
+            method: 'POST',
+            outputBuilder: async (res) => ({
+                choices: [{ message: { content: res.response } }],
+            }),
+            req: {
+                envelope: 'json',
+                builder: async () => ({
+                    model: req.model,
+                    prompt: firstMessage.content,
+                    stream: false,
+                }),
+            },
+            urlBuilder: async () => `${this.s().oll_base_url}/api/generate`,
+        });
+    }
+};
+OllamaLLMManager = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], OllamaLLMManager);
+export { OllamaLLMManager };

package/dist/esm/std/impl/OpenAILLMManager.d.ts

@@ -0,0 +1,17 @@
+import type { ApiKey } from '../../dt/index.js';
+import type { HTTPAPICaller } from '../HTTPAPICaller.js';
+import type { LLMManager, LLMManagerSendReq, LLMManagerSendRes } from '../LLMManager.js';
+import type { Configurable, Settings, SettingsManager } from '../SettingsManager.js';
+export interface OpenAILLMManagerSettings extends Settings {
+    oai_api_key: ApiKey;
+}
+type S = OpenAILLMManagerSettings;
+export declare class OpenAILLMManager implements Configurable<S>, LLMManager {
+    private httpAPICaller;
+    private settingsManager;
+    private static BASE_URL;
+    constructor(httpAPICaller: HTTPAPICaller, settingsManager: SettingsManager<S>);
+    s(): OpenAILLMManagerSettings;
+    send(req: LLMManagerSendReq): Promise<LLMManagerSendRes>;
+}
+export {};

package/dist/esm/std/impl/OpenAILLMManager.js

@@ -0,0 +1,51 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var OpenAILLMManager_1;
+import { inject, injectable } from 'inversify';
+let OpenAILLMManager = class OpenAILLMManager {
+    static { OpenAILLMManager_1 = this; }
+    httpAPICaller;
+    settingsManager;
+    static BASE_URL = 'https://api.openai.com/v1';
+    constructor(httpAPICaller, settingsManager) {
+        this.httpAPICaller = httpAPICaller;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            oai_api_key: this.settingsManager.get()('oai_api_key'),
+        };
+    }
+    async send(req) {
+        return await this.httpAPICaller.exec({
+            authorizationHeader: {
+                value: this.s().oai_api_key,
+                prefix: 'Bearer',
+            },
+            errBuilder: async (error) => error.error.message,
+            method: 'POST',
+            req: {
+                envelope: 'json',
+                builder: async () => req,
+            },
+            urlBuilder: async () => `${OpenAILLMManager_1.BASE_URL}/chat/completions`,
+        });
+    }
+};
+OpenAILLMManager = OpenAILLMManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('HTTPAPICaller')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], OpenAILLMManager);
+export { OpenAILLMManager };

package/dist/esm/std/impl/SimpleHTTPAPICaller.js

@@ -64,6 +64,7 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         if (status === 202 || status === 204) {
             return {};
         }
+        // Using .startsWith instead of === because the value can look like this 'application/json; charset=utf-8'
         const responseContentType = headers.get('Content-Type');
         const isJSON = responseContentType?.startsWith('application/json');
         const isFormURLEncoded = responseContentType?.startsWith('application/x-www-form-urlencoded');
@@ -87,6 +88,10 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
     async computeHeaders({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', req, }) {
         const headers = {};
         if (req?.envelope !== 'form-data') {
+            // The boundary needs to be set when sending data this way, so the server can understand how to read it (Source : https://stackoverflow.com/a/20321259/1259118)
+            // In RN, the content-type we set is automatically overriden by the internal fetch client (i.e. 'content-type': 'multipart/form-data; boundary=7ZsqoHiTstShSc4-Yi4U7ier3GPc_4QL5iN2eT9rnSNd0g1UoFPgt3I6.fsWlV8YpJhFkG')
+            // In CLI, if it is set, it's not overriden. So it creates problems. With 'form-data', we send 'content-type': 'multipart/form-data'` but the server expects something like 'content-type': 'multipart/form-data;boundary=--------------------------743913816161509008636675'
+            // So we don't set it at all and we're good to go.
             headers['Content-Type'] = contentType;
         }
         if (authorizationHeader) {
@@ -110,6 +115,8 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
         return headers;
     }
     async processResBad({ errBuilder, opts, }, isJSON, isXML, response) {
+        // NOTE : This method must handle all possible cases and never throw
+        // Indeed, it's supposed to handle the errors so it shouldn't throw one
         let error;
         try {
             if (isJSON) {
@@ -134,6 +141,7 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             return null;
         }
         if (typeof error === 'string') {
+            // For example, it can be from `asText`, containing funny formatting (developers and errors you know...)
             return error.trim();
         }
         if (!error) {
@@ -144,10 +152,14 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             if (typeof message === 'string') {
                 return message;
             }
+            // Case where `errBuilder` is of type (error: string) => string
+            // If an object is passed to it, it would return an object instead, interpreted incorrectly as [object Object] by error handlers
             return JSON.stringify(message);
         }
         catch (err) {
             this.logger.error(err);
+            // Case where `errBuilder` is of type (error: Object) => string
+            // If an object of another shape is passed to it, it would trigger some TypeError or cannot call .message of undefined
             return JSON.stringify(error);
         }
     }
@@ -163,7 +175,9 @@ let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
             });
             if (isFormURLEncoded) {
                 payload = {};
+                // TODO : Find a better way to do this (without adding any external dependency because the code must be portable)
                 new URL(`http://localhost?${asText}`).searchParams.forEach((v, k) => {
+                    // @ts-ignore
                     payload[k] = v;
                 });
             }

package/dist/esm/std/impl/SimpleMapI18nManager.js

@@ -17,7 +17,7 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
     static { SimpleMapI18nManager_1 = this; }
     i18n;
     logger;
-    static PLACEHOLDERS_REGEX = /{{([A-Z-a-z0-9]+)}}/g;
+    static PLACEHOLDERS_REGEX = /{{([A-Z-a-z0-9]+)}}/g; // Note the 'g' so it can be used with `matchAll`
     entries;
     constructor(i18n, logger) {
         this.i18n = i18n;
@@ -48,12 +48,14 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
         if (opts?.fallback) {
             return opts.fallback;
         }
-        return key;
+        return key; // Mimic the behavior of some common libraries like i18next
     }
     tOrNull(key, _opts) {
         return this.entries.get(key) || null;
     }
     replacePlaceholders(v, opts) {
+        // DO NOT USE THIS IN PRODUCTION
+        // The purpose of it is to have a simple and dependency-less implementation, to play with
         let res = v;
         const placeholders = res.matchAll(SimpleMapI18nManager_1.PLACEHOLDERS_REGEX);
         for (const [placeholder, key] of placeholders) {

package/dist/esm/std/impl/StdDateClockManager.js

@@ -10,6 +10,9 @@ let StdDateClockManager = class StdDateClockManager {
         return new Date();
     }
     nowToKey() {
+        // The rationale behind this being hardcoded is to avoid adding a library (luxon, date-fns) just for that.
+        // For instance, luxon adds a huge amount of code to a basic web target when bundled, for nothing.
+        // See https://github.com/moment/luxon/issues/854#issuecomment-1729384672
         return this.now()
             .toISOString()
             .replaceAll(/-|T|:/g, '')

package/dist/esm/std/impl/UCDataStoreExternalResourceManager.js

@@ -11,6 +11,9 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
+// TODO : Wait for the DB to be ready or add a retry mechanism
+// Because when we start from a fresh install, this is executed before the docker container is ready
+// A temporary workaround is to stop and restart everything. At the 2nd startup, the db is ready, and it works
 let UCDataStoreExternalResourceManager = class UCDataStoreExternalResourceManager {
     ucDataStore;
     constructor(ucDataStore) {

package/dist/esm/std/impl/WebCryptoManager.js

@@ -10,6 +10,7 @@ const DIGEST_MAPPING = new Map([
 ]);
 let WebCryptoManager = class WebCryptoManager {
     async clear() {
+        // Nothing to do
     }
     hash(_algorithm, _base) {
         throw new Error('Method not implemented.');
@@ -25,9 +26,13 @@ let WebCryptoManager = class WebCryptoManager {
         if (!hash) {
             throw new Error(`Digest ${digest} is not valid for WebCryptoManager`);
         }
+        // "Secure context: This feature is available only in secure contexts (HTTPS), in some or all supporting browsers."
+        // Warning: This API provides a number of low-level cryptographic primitives. It's very easy to misuse them, and the pitfalls involved can be very subtle.
+        // https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto
         const textEncoder = new TextEncoder();
         const passwordKey = await crypto.subtle.importKey('raw', textEncoder.encode(password), 'PBKDF2', false, ['deriveBits']);
         const result = await crypto.subtle.deriveBits({
+            // https://developer.mozilla.org/en-US/docs/Web/API/Pbkdf2Params
             hash,
             iterations: iterationsCount,
             name: 'PBKDF2',
@@ -36,9 +41,11 @@ let WebCryptoManager = class WebCryptoManager {
         return new Uint8Array(result);
     }
     async randomString(length) {
+        // Not perfect in terms of randomness (because of Math.random() but pretty fine for now)
         let res = '';
         while (res.length < length) {
             const next = Math.random().toString(36).slice(2, 3);
+            // For now, we want only chars at the beginning, so it can be used as an identifier (i.e. in a database)
             if (res.length === 0 &&
                 Number.isInteger(Number.parseInt(next, 10))) {
                 continue;
@@ -48,6 +55,8 @@ let WebCryptoManager = class WebCryptoManager {
         return res;
     }
     randomUUID() {
+        // "Secure context: This feature is available only in secure contexts (HTTPS), in some or all supporting browsers."
+        // https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID
         return crypto.randomUUID();
     }
     async scrypt() {

package/dist/esm/std/index.d.ts

@@ -13,6 +13,7 @@ export * from './HTTPAPICallExecutor.js';
 export * from './I18nManager.js';
 export * from './JobManager.js';
 export * from './JWTManager.js';
+export * from './LLMManager.js';
 export * from './Logger.js';
 export * from './PromptManager.js';
 export * from './SettingsManager.js';

package/dist/esm/std/index.js

@@ -13,6 +13,7 @@ export * from './HTTPAPICallExecutor.js';
 export * from './I18nManager.js';
 export * from './JobManager.js';
 export * from './JWTManager.js';
+export * from './LLMManager.js';
 export * from './Logger.js';
 export * from './PromptManager.js';
 export * from './SettingsManager.js';

package/dist/esm/target/lib/cli/renderer.js

@@ -1,5 +1,6 @@
 import { CustomError } from '../../../error/index.js';
 export function print(line) {
+    // biome-ignore lint/suspicious/noConsole: we want it
     console.info(line);
 }
 export function printError(err) {
@@ -7,11 +8,13 @@ export function printError(err) {
     if (err instanceof Error) {
         message = err.message;
         if (!(err instanceof CustomError)) {
+            // biome-ignore lint/suspicious/noConsole: we want it
             console.error(err);
         }
     }
     else if (typeof err === 'string') {
         message = err;
     }
+    // biome-ignore lint/suspicious/noConsole: we want it
     console.error(message);
 }

package/dist/esm/target/lib/client/consts.d.ts

@@ -1,2 +1,5 @@
 import type { ServerClientManagerSettings } from './ServerClientManager.js';
+/**
+ * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
+ */
 export declare const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS: ServerClientManagerSettings;

package/dist/esm/target/lib/client/consts.js

@@ -1,3 +1,6 @@
+/**
+ * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
+ */
 export const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS = {
     server_public_api_key: 'PublicApiKeyToBeChangedWhenDeploying',
     server_public_api_key_header_name: 'X-API-Key',

package/dist/esm/target/lib/mcp-server/MCPServerBooter.js

@@ -32,6 +32,7 @@ let MCPServerBooter = class MCPServerBooter {
                 srcImporter,
             });
             for await (const uc of ucs) {
+                // Declared only for compatibility with ServerManager's contract but not used
                 const contract = ucHTTPContract(uc);
                 await this.ucManager.initServer(uc);
                 await this.serverManager.mount(uc.appManifest, uc.def, contract);

package/dist/esm/target/lib/react/UCContainer.js

@@ -15,6 +15,7 @@ export function UCContainer({ children, uc, }) {
         })();
     }, [uc, ucExecChecker]);
     if (isAllowed === undefined) {
+        // TODO : Add some loader while we check if can do
         return React.createElement(React.Fragment, null);
     }
     if (isAllowed === false) {

package/dist/esm/target/lib/react/UCPanel.js

@@ -33,6 +33,9 @@ export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onErr
     };
     const onSubmit = async () => {
         setExecState('submitting');
+        // Is some targets, the confirmClient blocks the main thread (e.g. window.confirm()).
+        // This leads to the state set above not being updated.
+        // This is a "hacky" workaroud to let React re-render the control with 'submitting' state before
         await sleep(100);
         await onStartSubmitting?.();
         const confirmed = await ucManager.confirmClient(uc);
@@ -62,6 +65,7 @@ export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onErr
     };
     const disabled = ucIsDisabled(execState);
     const loading = ucIsLoading(execState);
+    // TODO : Keep these as a state to avoid recomputation
     const ctx = {
         clearAfterExec,
         disabled,

package/dist/esm/target/lib/react/useUC.d.ts

@@ -2,6 +2,14 @@ import { type ArgsRecord, UC, type UCDef, type UCInput, type UCOPIBase } from '.
 type CloneFunc<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (i: Partial<I>) => UC<I, OPI0, OPI1>;
 type DivertFunc<II extends UCInput | undefined = undefined, OOPI0 extends UCOPIBase | undefined = undefined, OOPI1 extends UCOPIBase | undefined = undefined> = (siblingUCD: UCDef) => UC<II, OOPI0, OOPI1>;
 type RefillFunc<I extends UCInput | undefined = undefined> = (i: Partial<I>) => void;
+/**
+ * This hook provides utilities to init a use case and perform actions on it in a React way
+ * @param appManifest
+ * @param def
+ * @param auth
+ * @param opts
+ * @returns
+ */
 export declare function useUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: ArgsRecord<I, OPI0, OPI1>['appManifest'], def: ArgsRecord<I, OPI0, OPI1>['def'], auth: ArgsRecord<I, OPI0, OPI1>['auth'], opts?: {
     fillWith: Partial<I>;
 }): [

package/dist/esm/target/lib/react/useUC.js

@@ -1,5 +1,13 @@
 import { useState } from 'react';
 import { UC, } from '../../../uc/index.js';
+/**
+ * This hook provides utilities to init a use case and perform actions on it in a React way
+ * @param appManifest
+ * @param def
+ * @param auth
+ * @param opts
+ * @returns
+ */
 export function useUC(appManifest, def, auth, opts) {
     const [uc, setUC] = useState(() => {
         const { name: appName, ucReg } = appManifest;
@@ -13,8 +21,22 @@ export function useUC(appManifest, def, auth, opts) {
         }
         return v;
     });
+    /**
+     * Get a new `UC` based on the initial one
+     * @param i
+     * @returns
+     */
     const clone = (i) => new UC(uc.appManifest, uc.def, uc.auth).fill(i);
+    /**
+     * Get a new `UC` based on the "common" settings of the initial one (i.e. `auth`)
+     * @param ucd
+     * @returns
+     */
     const divert = (siblingUCD) => new UC(uc.appManifest, siblingUCD, uc.auth);
+    /**
+     * Update the existing `uc` in an immutable way to trigger components re-rendering
+     * @param i
+     */
     const refill = (i) => {
         setUC(new UC(uc.appManifest, uc.def, uc.auth).fill(i));
     };

package/dist/esm/target/lib/react/useUCOR.d.ts

@@ -2,6 +2,21 @@ import type { UCInput, UCOPIBase, UCOutputReader, UCOutputReaderPart } from '../
 type AppendFunc<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<any, OPI0, OPI1>) => void;
 type RemoveFunc<OPI extends UCOPIBase> = (item: OPI) => void;
 type UpdateFunc<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<any, OPI0, OPI1>) => void;
+/**
+ * This hook provides utilities to act on a {@link UCOutputReader} in a React way
+ *
+ * A usual scenario of this is a "CRUD-like" UI displaying multiple use cases :
+ *
+ *   - A `List` use case to display a collection of items
+ *   - A `Create` use case to add an item
+ *   - A `Delete` use case to remove an item
+ *   - An `Update` use case to update an item
+ *
+ * Whenever one of this use case is performed, you can use the `ucor` to act on the main UCOR in an immutable way.
+ *
+ * @param ucor
+ * @returns
+ */
 export declare function useUCOR<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucor: UCOutputReader<I, OPI0, OPI1>): [
     UCOutputReaderPart<NonNullable<OPI0>> | undefined,
     UCOutputReaderPart<NonNullable<OPI1>> | undefined,

package/dist/esm/target/lib/react/useUCOR.js

@@ -39,10 +39,35 @@ function update(a, b) {
         items: newItems,
     };
 }
+/**
+ * This hook provides utilities to act on a {@link UCOutputReader} in a React way
+ *
+ * A usual scenario of this is a "CRUD-like" UI displaying multiple use cases :
+ *
+ *   - A `List` use case to display a collection of items
+ *   - A `Create` use case to add an item
+ *   - A `Delete` use case to remove an item
+ *   - An `Update` use case to update an item
+ *
+ * Whenever one of this use case is performed, you can use the `ucor` to act on the main UCOR in an immutable way.
+ *
+ * @param ucor
+ * @returns
+ */
 export function useUCOR(ucor) {
     const [part0, setPart0] = useState(ucor.part0());
     const [part1, setPart1] = useState(ucor.part1());
+    /**
+     * Append items to part0
+     * @param ucor2
+     * @returns
+     */
     const append0 = (ucor2) => setPart0((prev) => append(prev, ucor2.part0()));
+    /**
+     * Append items to part1 (if applicable)
+     * @param ucor2
+     * @returns
+     */
     const append1 = (ucor2) => setPart1((prev) => {
         const b = ucor2.part1();
         if (!prev || !b) {
@@ -50,14 +75,34 @@ export function useUCOR(ucor) {
         }
         return append(prev, b);
     });
+    /**
+     * Remove the item from part0
+     * @param item
+     * @returns
+     */
     const remove0 = (item) => setPart0((prev) => remove(prev, item));
+    /**
+     * Remove the item from part1 (if applicable)
+     * @param item
+     * @returns
+     */
     const remove1 = (item) => setPart1((prev) => {
         if (!prev) {
             return;
         }
         return remove(prev, item);
     });
+    /**
+     * Update items in part0
+     * @param ucor2
+     * @returns
+     */
     const update0 = (ucor2) => setPart0((prev) => update(prev, ucor2.part0()));
+    /**
+     * Update items in part1 (if applicable)
+     * @param ucor2
+     * @returns
+     */
     const update1 = (ucor2) => setPart1((prev) => {
         const b = ucor2.part1();
         if (!prev || !b) {

package/dist/esm/target/lib/rn/input.d.ts

@@ -3,6 +3,13 @@ import { type DataType, type ErrorMessage } from '../../../dt/index.js';
 import { type UCExecState, type UCInputField } from '../../../uc/index.js';
 export interface RNInputDef {
     internal?: undefined;
+    /**
+     * Fields that are part of {@link TextInputProps}
+     *
+     * These are safe to destructure directly in a `<TextInput />` component.
+     *
+     * @example `<TextInput {...attrs.spec} />`
+     */
     spec?: TextInputProps;
 }
 export declare function rnInputDef<T extends DataType>(field: UCInputField<T>, execState: UCExecState, _errMsg: ErrorMessage | null): RNInputDef;

package/dist/esm/target/lib/rn/input.js

@@ -6,12 +6,14 @@ export function rnInputDef(field, execState, _errMsg) {
         spec: {},
     };
     if (!def.spec) {
+        // Just a guard to safely type the rest of the function without using !
         return def;
     }
     const { key, def: fDef } = field;
     const { type: fType } = fDef;
     def.spec.editable = !ucIsDisabled(execState);
     def.spec.id = ucifId(key);
+    // Testing the types by usage probability to make the if/else evaluation stop ideally earlier
     if (fType instanceof TString) {
         const constraints = fType.getConstraints();
         if (constraints) {

package/dist/esm/target/lib/server/AuthenticationChecker.js

@@ -35,7 +35,7 @@ let AuthenticationChecker = class AuthenticationChecker {
             authorizationHeader,
         });
         const output = {
-            allowed: false,
+            allowed: false, // By default it's not allowed
             auth: null,
         };
         const { lifecycle: { server }, sec, } = uc.def;
@@ -52,6 +52,7 @@ let AuthenticationChecker = class AuthenticationChecker {
             output.allowed = allowed;
         }
         else {
+            // Follows the OpenAPI spec : https://swagger.io/docs/specification/authentication
             switch (authType) {
                 case 'apiKey':
                     if (authorizationHeader &&

package/dist/esm/target/lib/server/BasicAuthenticationChecker.js

@@ -46,6 +46,7 @@ let BasicAuthenticationChecker = class BasicAuthenticationChecker {
         if (!passwordsMatch) {
             return null;
         }
+        // TODO : Improve this by fetching data from a data store for example
         return {
             organization: {
                 id: '',

package/dist/esm/target/lib/server/CSPDirectivesBuilder.js

@@ -36,10 +36,23 @@ let CSPDirectivesBuilder = class CSPDirectivesBuilder {
         this.logger.info('Default CSP directives', defaultDirectives);
         const directives = { ...defaultDirectives };
         if (!this.environmentManager.isProd()) {
+            // In dev mode, we allow ourselves to remove this directive.
+            // It is necessary when testing from an external device and accessing the server via 192.168.x.x for example
+            // Otherwise the requests are upgraded and it doesn't work since there is no HTTPS in localhost
+            // Source : https://stackoverflow.com/questions/66599655/how-to-enable-and-disable-upgradeinsecurerequests-csp-directive-using-helmet-4-4
             this.logger.warn('Disabling upgrade-insecure-requests');
             directives['upgrade-insecure-requests'] = null;
+            // In dev mode, NextJS uses eval
+            // Enabling it prevents the following error from occurring in the console
+            // Uncaught EvalError: call to eval() blocked by CSP NextJS
+            // Source : https://github.com/vercel/next.js/discussions/17396
             this.logger.warn('Enabling unsafe-eval');
             directives[CSPDirectivesBuilder_1.SCRIPT_SRC]?.push("'unsafe-eval'");
+            // In dev mode, React Dev Tools use inline injection
+            // Enabling it prevents the following error from occurring in the console
+            // Content Security Policy: The page’s settings blocked the loading of a resource at inline (“script-src”).
+            // Download the React DevTools for a better development experience: https://reactjs.org/link/react-devtools
+            // Uncaught TypeError: hook.sub is not a function
             this.logger.warn('Enabling unsafe-inline');
             directives[CSPDirectivesBuilder_1.SCRIPT_SRC]?.push("'unsafe-inline'");
         }

package/dist/esm/target/lib/server/CustomerFacingErrorBuilder.js

@@ -21,11 +21,14 @@ let CustomerFacingErrorBuilder = class CustomerFacingErrorBuilder {
     }
     exec({ error }) {
         if (error instanceof CustomError) {
+            // It's already ready to be sent as is
             return {
                 error,
             };
         }
         this.logger.error(error);
+        // Create a specific generic error to avoid leaking potentially sensitive error
+        // We all know the infamous "Cannot connect to MySQL database"...
         return {
             error: new InternalServerError(this.environmentManager.isProd()
                 ? undefined

package/dist/esm/target/lib/server/PrivateApiKeyAuthenticationChecker.js

@@ -31,6 +31,7 @@ let PrivateApiKeyAuthenticationChecker = class PrivateApiKeyAuthenticationChecke
         if (!exists) {
             return null;
         }
+        // TODO : Improve this by fetching data from a data store for example
         return {
             organization: {
                 id: '',

package/dist/esm/target/lib/server/PublicApiKeyChecker.js

@@ -27,7 +27,7 @@ let PublicApiKeyChecker = class PublicApiKeyChecker {
     }
     async exec({ checkType = DEFAULT_UC_SEC_PAKCT, value, }) {
         this.logger.trace('Checking apiKey', { checkType, value });
-        let allowed = false;
+        let allowed = false; // By default it's not allowed
         switch (checkType) {
             case 'off':
                 allowed = true;