libmodulor 0.3.0 → 0.5.0

package/dist/esm/testing/impl/VitestAppTestSuiteEmitter.js

@@ -19,6 +19,7 @@ let VitestAppTestSuiteEmitter = class VitestAppTestSuiteEmitter {
     }
     async exec({ appPath, depsMapping, idx, monkeyTestingTimeoutInMs, serverPortRangeStart, }) {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
+        // Since we're using 'recursive: true', there will be no error if the directory already exists
         await this.fsManager.mkdir(testPath, { recursive: true });
         const outPath = this.fsManager.path(testPath, APP_TEST_MAIN_FILE_NAME);
         let tpl = template(serverPortRangeStart, idx, monkeyTestingTimeoutInMs);
@@ -37,6 +38,11 @@ VitestAppTestSuiteEmitter = __decorate([
     __metadata("design:paramtypes", [Object])
 ], VitestAppTestSuiteEmitter);
 export { VitestAppTestSuiteEmitter };
+// For now, we can have it here. When it becomes harder to maintain, we can introduce some kind of template engine.
+// Be aware that this will introduce complexities on building the lib.
+// We'll need to include these templates in the build and make them accessible via package.json "exports" or any other mechanism.
+// Hence the choice to keep it simple for now.
+// Defined it as function in case we need to pass args.
 const template = (serverPortRangeStart, idx, monkeyTestingTimeoutInMs) => `/*
     All this code has been auto generated.
     DO NOT EDIT.

package/dist/esm/testing/opts.d.ts

@@ -5,25 +5,63 @@ import type { AppTesterCtx } from './ctx.js';
 type AppTesterOptsAliasPrefix = string;
 type AppTesterOptsImportsList = string[];
 export interface AppTesterTypeScriptOpts {
+    /**
+     * Although the TS lib relies on an enum (`ModuleKind`), we use plain text so it's compatible with a regular tsconfig.json
+     * @see https://www.typescriptlang.org/tsconfig/#module
+     * @defaultValue "NodeNext"
+     */
     module?: string;
+    /**
+     * Although the TS lib relies on an enum (`ModuleResolutionKind`), we use plain text so it's compatible with a regular tsconfig.json
+     * @see https://www.typescriptlang.org/tsconfig/#moduleResolution
+     * @defaultValue "NodeNext"
+     */
     moduleResolution?: string;
+    /**
+     * @see https://www.typescriptlang.org/tsconfig/#noCheck
+     * @defaultValue true
+     */
     noCheck?: boolean;
+    /**
+     * @see https://www.typescriptlang.org/tsconfig/#skipLibCheck
+     * @defaultValue true
+     */
     skipLibCheck?: boolean;
+    /**
+     * Although the TS lib relies on an enum (`ScriptTarget`), we use plain text so it's compatible with a regular tsconfig.json
+     * @see https://www.typescriptlang.org/tsconfig/#target
+     * @defaultValue "ESNext"
+     */
     target?: string;
 }
 export type AppTesterOpts = Partial<Pick<LoggerSettings, 'logger_level'>> & {
     source?: {
         imports?: {
             external?: {
+                /**
+                 * @defaultValue '@'
+                 */
                 aliasPrefix?: AppTesterOptsAliasPrefix;
+                /**
+                 * @defaultValue ['fik-sdk', 'inversify']
+                 */
                 allowed?: AppTesterOptsImportsList;
             };
             internal?: {
+                /**
+                 * @defaultValue '../../'
+                 */
                 maxDepth?: FilePath;
+                /**
+                 * @defaultValue '.'
+                 */
                 startChar?: string;
             };
         };
         ts?: {
+            /**
+             * @defaultValue tsconfig.json
+             */
             configFileName?: FileName;
         } & AppTesterTypeScriptOpts;
     };

package/dist/esm/testing/opts.js

@@ -1,5 +1,5 @@
 export const DEFAULT_APP_TESTER_OPTS = {
-    logger_level: 'error',
+    logger_level: 'error', // Having 'debug' makes the test output bloated so it's opt-in
     source: {
         imports: {
             external: {

package/dist/esm/testing/uc-input.js

@@ -33,11 +33,13 @@ export function onlySetProgrammaticallyWithExamples(uc) {
         fillWithExample(f);
     }
 }
+// biome-ignore lint/suspicious/noExplicitAny: can be anything
 function fillWithExample(f) {
     const { type } = f.def;
     let val = type.getExamples()?.[0] ?? type.example();
     if (type instanceof TFile) {
         const file = val;
+        // TODO : Consider building a real file with real data (e.g. image, pdf, txt, etc.)
         val = new File(['01010101010101010101010101010101'], file.path, {
             type: file.type,
         });

package/dist/esm/testing/workers/AppTesterCtxInitializer.js

@@ -28,6 +28,10 @@ let AppTesterCtxInitializer = class AppTesterCtxInitializer {
         const filePaths = await this.fsManager.ls(ucdsPath);
         const ucdFilePaths = filePaths.filter(({ path, type }) => path.endsWith(UC_DEF_FILE_NAME_SUFFIX) &&
             type === FSManagerItemInfoType.FILE);
+        // Initially, this was using Promise.all.
+        // But in some cases, it hangs. I didn't investigate more, but I suspect some lock on the CPU or FileSystem.
+        // There were exactly 6 use cases.
+        // Since 'for await of' fixes it, let's just use and investigate when we have more time.
         const ucdRefs = [];
         for await (const { path } of ucdFilePaths) {
             ucdRefs.push({
@@ -36,6 +40,9 @@ let AppTesterCtxInitializer = class AppTesterCtxInitializer {
                 name: path.replace(UC_DEF_FILE_NAME_SUFFIX, ''),
             });
         }
+        // Sorting is necessary because the file system sorting is not necessarily the same as A-Z sorting.
+        // Indeed, CreatePostUCD will arrive after CreatePostCommentUCD in the file system.
+        // But in alphabetical order, CreatePost should arrive before CreatePostComment.
         ucdRefs.sort((a, b) => a.name.localeCompare(b.name));
         return {
             ctx: {

package/dist/esm/testing/workers/UCExecutor.js

@@ -43,6 +43,7 @@ let UCExecutor = class UCExecutor {
                 o: null,
             },
         };
+        // In a typical scenario, client calls the server so only the client actually needs to be called here
         await this.execClient(appManifest, ucd, out);
         return {
             out,

package/dist/esm/testing/workers/checkers/AppIndexChecker.js

@@ -21,6 +21,7 @@ let AppIndexChecker = class AppIndexChecker {
         this.output = { errors: [] };
     }
     async exec({ appPath }) {
+        // TODO : Consider changing this to await import like the other checkers
         const contents = await this.fsManager.cat(this.fsManager.path(appPath, APP_INDEX_FILE_NAME));
         this.makeSureExposesNecessary(contents);
         return this.output;

package/dist/esm/testing/workers/checkers/UCDefSourcesChecker.js

@@ -21,6 +21,7 @@ const ERR_UCD_IMPORTS_INTERNAL_MAX_DEPTH = (maxDepth) => `Internal imports must
 const ERR_UCD_INPUT_FIELD_PATTERN = () => `The input field def must match ${UC_INPUT_FIELD_PATTERN}`;
 const ERR_UCD_INPUT_TYPE_NAME = (ucName) => `The input type must be named ${ucName}${UC_INPUT_SUFFIX}`;
 const ERR_UCD_OPI_TYPE_NAME = (ucName, idx) => `The OPI must be named ${ucName}${UC_OPI_SUFFIX}${idx}`;
+// TODO : Improve the check* methods that look a little bit hacky
 let UCDefSourcesChecker = class UCDefSourcesChecker {
     fsManager;
     logger;
@@ -37,6 +38,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
     }
     async exec({ ctx }) {
         const { appPath, opts } = ctx;
+        // TODO : Consider removing this and using profiling when needed
         const startTime = new Date().getTime();
         this.logger.debug('UCDefSourceChecker starting', {
             appPath,
@@ -96,6 +98,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 continue;
             }
             const [_name, type] = parts;
+            // trim because we process `name: Type` if the code is linted correctly
             f.err =
                 type?.trim().match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null
                     ? null
@@ -155,6 +158,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
         const fieldsKey = `${key}Fields`;
         item[fieldsKey] = fields;
         for (const f of item[fieldsKey]) {
+            // There are no specific validation rules for OPIx for now
             f.err = null;
         }
     }

package/dist/esm/uc/UC.js

@@ -8,6 +8,7 @@ export class UC {
     appManifest;
     def;
     auth;
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     inputFields;
     constructor(appManifest, def, auth) {
         this.appManifest = appManifest;
@@ -15,11 +16,15 @@ export class UC {
         this.auth = auth;
         const iFields = def.io.i?.fields;
         this.inputFields = iFields
-            ? Object.entries(iFields).map(([key, def]) => new UCInputField(key, def))
+            ? Object.entries(iFields).map(([key, def]) => new UCInputField(key, 
+            // biome-ignore lint/suspicious/noExplicitAny: can be anything
+            def))
             : [];
     }
     clear() {
         for (const f of this.inputFields) {
+            // We clear only the fields that have been filled manually
+            // For example, fields marked as `UCInputFieldFillingMode.AUTO_PRE` are not cleared so they can be reused in the use case
             if (!ucifMustBeFilledManually(f.def)) {
                 continue;
             }
@@ -27,6 +32,8 @@ export class UC {
         }
     }
     clearSensitiveInputFields() {
+        // TODO : Check how we can automate this before and .persist operation
+        // Be careful with the fields that are saved but hashed before (e.g. password).
         for (const f of this.inputFieldsSensitive()) {
             f.clear();
         }
@@ -53,6 +60,7 @@ export class UC {
         }
         return field;
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     inputFieldsForForm() {
         const ordered = this.inputFieldsOrdered().filter((f) => ucifMustBeFilledManually(f.def));
         const dependencies = this.def.io.i?.dependencies;
@@ -69,6 +77,7 @@ export class UC {
             return blankDepsValues.length === 0;
         });
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     inputFieldsOrdered() {
         const order = this.def.io.i?.order;
         if (!order) {
@@ -86,9 +95,11 @@ export class UC {
             return 0;
         });
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     inputFieldsInsensitive() {
         return this.inputFields.filter((f) => !ucifIsSensitive(f.def));
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     inputFieldsSensitive() {
         return this.inputFields.filter((f) => ucifIsSensitive(f.def));
     }
@@ -97,6 +108,7 @@ export class UC {
         if (fields.length === 0) {
             return false;
         }
+        // TODO : Avoid this workaround when we figure out how to let the user change these values in terms of UI
         const isListInput = Object.keys(ListInputDef.fields)
             .sort((a, b) => a.localeCompare(b))
             .join('') ===
@@ -126,13 +138,18 @@ export class UC {
     rValArr(key) {
         return this.inputField(key).rValArr();
     }
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     validate() {
+        // This implementation returns an error as soon as one is met.
+        // This can be discussed later as we can also return an array of errors all at once.
+        // Unary fields
         for (const f of this.inputFields) {
             const validation = f.validate();
             if (!validation.isOK()) {
                 return [f, validation];
             }
         }
+        // Fields combinations
         const combinedValidation = this.def.io.i?.validation;
         if (!combinedValidation) {
             return null;
@@ -148,6 +165,7 @@ export class UC {
             const validation = new Validation();
             validation.add({
                 constraint: 'fieldsOr',
+                // TODO : Display the translated labels and not the keys
                 expected: or.join(', '),
             });
             return [null, validation];

package/dist/esm/uc/UCInputField.d.ts

@@ -5,14 +5,42 @@ import { rVal0, rValArr, type reqVal0 } from './utils/rVal.js';
 export declare class UCInputField<T extends DataType> {
     key: UCFieldKey;
     def: UCInputFieldDef<T>;
+    /**
+     * In some cases, the wording needs to be adapted in function of the context and not be statically fetched from {@link I18nManager}.
+     *
+     * For instance, when the user does X, then the description becomes Y.
+     */
     private dynamicWording;
     private value;
     constructor(key: UCFieldKey, def: UCInputFieldDef<T>);
     clear(): void;
     getDynamicWording(): Partial<UCWording> | undefined;
     getValue(): UCInputFieldValue<T>;
+    /**
+     * Read the value as a primitive
+     *
+     * Unlike the standalone {@link rVal0}, it returns the default value if present.
+     *
+     * @returns
+     */
     rVal0(): ReturnType<typeof rVal0<T>>;
+    /**
+     * Require the value as a primitive
+     *
+     * Unlink the standalone {@link reqVal0}, it returns the default value if present.
+     *
+     * Otherwise, it throws an error.
+     *
+     * @returns
+     */
     reqVal0(): ReturnType<typeof reqVal0<T>>;
+    /**
+     * Require the value as an array
+     *
+     * Unlink the standalone {@link rValArr}, it returns the default value in an array if present.
+     *
+     * @returns
+     */
     rValArr(): ReturnType<typeof rValArr<T>>;
     setValue(op: UCInputFieldChangeOperator, value: UCInputFieldValue<T>): void;
     updateDef(def: UCInputFieldDef<T>): void;

package/dist/esm/uc/UCInputField.js

@@ -6,6 +6,11 @@ import { ucifcoIsForArray } from './utils/ucifcoIsForArray.js';
 export class UCInputField {
     key;
     def;
+    /**
+     * In some cases, the wording needs to be adapted in function of the context and not be statically fetched from {@link I18nManager}.
+     *
+     * For instance, when the user does X, then the description becomes Y.
+     */
     dynamicWording;
     value;
     constructor(key, def) {
@@ -29,6 +34,13 @@ export class UCInputField {
     getValue() {
         return this.value;
     }
+    /**
+     * Read the value as a primitive
+     *
+     * Unlike the standalone {@link rVal0}, it returns the default value if present.
+     *
+     * @returns
+     */
     rVal0() {
         const val = rVal0(this.value);
         if (!isBlank(val)) {
@@ -40,9 +52,19 @@ export class UCInputField {
         }
         return null;
     }
+    /**
+     * Require the value as a primitive
+     *
+     * Unlink the standalone {@link reqVal0}, it returns the default value if present.
+     *
+     * Otherwise, it throws an error.
+     *
+     * @returns
+     */
     reqVal0() {
         if (!isBlank(this.value)) {
             if (Array.isArray(this.value)) {
+                // Throwing an Error and not a IllegalArgumentError because this is usually the developer's fault.
                 throw new Error('The value is an array. Use rValArr instead.');
             }
             return this.value;
@@ -51,19 +73,31 @@ export class UCInputField {
         if (defaultValue !== undefined) {
             return defaultValue;
         }
+        // Throwing an Error and not an IllegalArgumentError because this is usually the developer's fault.
         throw new Error(`${this.key.toString()} is not set and has no default value. Do not require it.`);
     }
+    /**
+     * Require the value as an array
+     *
+     * Unlink the standalone {@link rValArr}, it returns the default value in an array if present.
+     *
+     * @returns
+     */
     rValArr() {
         if (!isBlank(this.value)) {
             if (!Array.isArray(this.value)) {
+                // Throwing an Error and not a IllegalArgumentError because this is usually the developer's fault.
                 throw new Error('The value is a primitive. Use reqVal0 instead.');
             }
             return this.value;
         }
         const defaultValue = this.def.type.getDefaultValue();
         if (defaultValue !== undefined) {
+            // We might need to allow multiple default values to handle all the cases.
             return [defaultValue];
         }
+        // Unlike in reqVal0, we return a default empty array anyways to make it usable.
+        // Otherwise, we could not get the value of an optional repeatable field (see remark above on the defaultValue).
         return [];
     }
     setValue(op, value) {
@@ -78,6 +112,7 @@ export class UCInputField {
             return;
         }
         if (!ucifcoIsForArray(op)) {
+            // Using a switch, even for just one case, to have it trigger an error if we miss to handle an enum value
             switch (op) {
                 case UCInputFieldChangeOperator.SET:
                     this.value = val;
@@ -89,6 +124,7 @@ export class UCInputField {
         }
         const current = Array.isArray(this.value) ? this.value : [];
         switch (op) {
+            // We are not really forced to use immutability here, but it's better for consistency
             case UCInputFieldChangeOperator.ADD:
                 this.value = current.concat([val]);
                 break;
@@ -110,6 +146,10 @@ export class UCInputField {
     }
     validateMandatoriness() {
         const validation = new Validation();
+        // We use `noContext: true` here to validate even the fields that should be set AUTO_PRE
+        // Even though it's an indicator that the developer made a mistake,
+        // we shouldn't send the error "X is not set and has no default value. Do not require it."
+        // to the user
         const needsValidation = ucifMustBeFilledManually(this.def, { noContext: true }) &&
             ucifIsMandatory(this.def) &&
             isBlank(this.value);
@@ -123,6 +163,8 @@ export class UCInputField {
         return validation;
     }
     validate() {
+        // Unlike UC.validate, this method returns all the errors at once.
+        // This can be discussed later to see if we want to harmonize.
         const validation = this.validateMandatoriness();
         if (this.value !== undefined && this.value !== null) {
             const [isRepeatable] = ucifRepeatability(this.def);

package/dist/esm/uc/data.d.ts

@@ -1,2 +1,5 @@
+/**
+ * Base interface all the use case data interfaces must extend
+ */
 export interface UCData {
 }

package/dist/esm/uc/def.d.ts

@@ -21,6 +21,13 @@ export interface UCDef<I extends UCInput | undefined = undefined, OPI0 extends U
     };
     lifecycle: {
         client?: UCClientDef<I, OPI0, OPI1>;
+        /**
+         * When bundling for clients, your bundler needs to strip the server definition to avoid bundling server side code for the client.
+         *
+         * For example with Webpack, you need to implement a custom loader.
+         *
+         * @see strip-ucd-lifecycle-server
+         */
         server?: UCServerDef<I, OPI0, OPI1> | true;
     };
     metadata: UCMetadata;

package/dist/esm/uc/exec.d.ts

@@ -1,7 +1,46 @@
+/**
+ * Mode of execution of a use case
+ *
+ * Unlike all the other enums, the values are lowercased for compatibility reasons.
+ * Indeed, this value is persisted in the database so we need to support all existing deployments.
+ */
 export declare enum UCExecMode {
+    /**
+     * The use case has been executed programmatically
+     */
     AUTO = "auto",
+    /**
+     * The use case has been executed explicitly by a user
+     */
     USER = "user"
 }
+/**
+ * State of execution of a use case
+ *
+ * - `changing`     : An action triggered a change, fields should be disabled
+ * - `idle`         : It can be touched and filled by the user
+ * - `initializing` : It's initializing in some way, fields should be disabled
+ * - `submitting`   : It's submitting, fields should be disabled and some indicator should show the processing
+ *
+ * It applies to a form, but it can be applied and generalized to any other interaction mechanism (i.e. cli, voice...).
+ */
 export type UCExecState = 'changing' | 'idle' | 'initializing' | 'submitting';
+/**
+ * Check whether the execution corresponds to a "disabled" state
+ *
+ * Typically, this is used in a form to derive the `disabled` attribute.
+ *
+ * @param execState
+ * @returns
+ */
 export declare function ucIsDisabled(execState: UCExecState): boolean;
+/**
+ * Check whether the execution corresponds to a "loading" state
+ *
+ * Typically, this is used to show a `loading` indicator. Thus, it's `true` when `execState === 'submitting'`.
+ * Note that it's not for `changing` or `initializing` because these are not triggered by the user per sé.
+ *
+ * @param execState
+ * @returns
+ */
 export declare function ucIsLoading(execState: UCExecState): boolean;

package/dist/esm/uc/exec.js

@@ -1,11 +1,40 @@
+/**
+ * Mode of execution of a use case
+ *
+ * Unlike all the other enums, the values are lowercased for compatibility reasons.
+ * Indeed, this value is persisted in the database so we need to support all existing deployments.
+ */
 export var UCExecMode;
 (function (UCExecMode) {
+    /**
+     * The use case has been executed programmatically
+     */
     UCExecMode["AUTO"] = "auto";
+    /**
+     * The use case has been executed explicitly by a user
+     */
     UCExecMode["USER"] = "user";
 })(UCExecMode || (UCExecMode = {}));
+/**
+ * Check whether the execution corresponds to a "disabled" state
+ *
+ * Typically, this is used in a form to derive the `disabled` attribute.
+ *
+ * @param execState
+ * @returns
+ */
 export function ucIsDisabled(execState) {
     return execState !== 'idle';
 }
+/**
+ * Check whether the execution corresponds to a "loading" state
+ *
+ * Typically, this is used to show a `loading` indicator. Thus, it's `true` when `execState === 'submitting'`.
+ * Note that it's not for `changing` or `initializing` because these are not triggered by the user per sé.
+ *
+ * @param execState
+ * @returns
+ */
 export function ucIsLoading(execState) {
     return execState === 'submitting';
 }

package/dist/esm/uc/ext.d.ts

@@ -5,12 +5,41 @@ import type { UCMountingPoint } from './utils/ucMountingPoint.js';
 export type UCHTTPMountingPoint = `/${URLPath}`;
 export interface UCExt<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
     cmd?: {
+        /**
+         * The command on which the use case is mounted at
+         *
+         * By default, it's mounted at `${fqucn}`.
+         */
         mountAt?: UCMountingPoint;
     };
     http?: {
+        /**
+         * The verb on which the use case is mounted at
+         *
+         * By default, it's computed from the {@link UCMetadata.action} with some specific heuristics.
+         *
+         * For instance, you can set `POST` even for a `List` use case, which usually defaults to `GET`.
+         * This can be useful in case you want the input to "travel" through the body of the request, and not the query params.
+         */
         method?: HTTPMethod;
+        /**
+         * The path on which the use case should mounted at
+         *
+         * By default, it's mounted at `/api/v1/${fqucn}`.
+         */
         mountAt?: UCHTTPMountingPoint;
+        /**
+         * The path on which the use case should also mounted at
+         *
+         * This is typically used when the mounting point is changed and you want to maintain a "legacy" endpoint for clients having
+         * a different release cycle than the server (e.g. a mobile app), who are still calling the old endpoint.
+         */
         mountAlsoAt?: UCHTTPMountingPoint[];
-        transform?: <T extends object>(output: UCOutput<OPI0, OPI1>) => T;
+        /**
+         * Transform the output received to fit with some specific cases where the endpoint is expected to respect a certain contract
+         * @param output
+         * @returns
+         */
+        transform?: (output: UCOutput<OPI0, OPI1>) => object;
     };
 }

package/dist/esm/uc/helpers/UCOutputBuilder.js

@@ -19,13 +19,17 @@ export class UCOutputBuilder {
     }
     addAll1(items) {
         this.init1IfNecessary();
+        // biome-ignore lint/style/noNonNullAssertion: set in the call above
         this.output.parts._1.items.push(...items);
+        // biome-ignore lint/style/noNonNullAssertion: set in the call above
         this.output.parts._1.total += items.length;
         return this;
     }
     add1(item) {
         this.init1IfNecessary();
+        // biome-ignore lint/style/noNonNullAssertion: set in the call above
         this.output.parts._1.items.push(item);
+        // biome-ignore lint/style/noNonNullAssertion: set in the call above
         this.output.parts._1.total += 1;
         return this;
     }
@@ -34,6 +38,7 @@ export class UCOutputBuilder {
     }
     count1() {
         this.init1IfNecessary();
+        // biome-ignore lint/style/noNonNullAssertion: set in the call above
         return this.output.parts._1.total;
     }
     has(predicate) {

package/dist/esm/uc/helpers/UCOutputReader.js

@@ -75,7 +75,9 @@ export class UCOutputReader {
             total = part.total;
         }
         return {
-            fields: allFieldsKeys.map((fieldKey) => new UCOutputField(fieldKey, allFields[fieldKey])),
+            fields: allFieldsKeys.map((fieldKey) => 
+            // biome-ignore lint/suspicious/noExplicitAny: can be anything
+            new UCOutputField(fieldKey, allFields[fieldKey])),
             idx,
             items,
             key,

package/dist/esm/uc/impl/HTTPUCTransporter.js

@@ -40,6 +40,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
         const publicApiKeyCheckType = sec?.publicApiKeyCheckType ?? DEFAULT_UC_SEC_PAKCT;
         switch (publicApiKeyCheckType) {
             case 'off':
+                // Nothing to do
                 break;
             case 'on': {
                 const publicApiKey = await this.serverClientManager.publicApiKey();
@@ -102,6 +103,9 @@ let HTTPUCTransporter = class HTTPUCTransporter {
             },
             urlBuilder: async () => `${baseURL}${path}`,
         });
+        // In case of 204, we get an empty object.
+        // Even though it makes deserializing easier, this is not considered a valid output.
+        // So we handle the case here.
         if (!res || Object.keys(res).length === 0) {
             return;
         }