libmodulor 0.4.0 → 0.6.0

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

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

@@ -19,6 +19,7 @@ function predicate(key, filter) {
     return (r) => r[key] === filter;
 }
 let InMemoryUCDataStore = class InMemoryUCDataStore {
+    // biome-ignore lint/suspicious/noExplicitAny: can be anything
     entries;
     tx;
     constructor() {
@@ -46,10 +47,13 @@ let InMemoryUCDataStore = class InMemoryUCDataStore {
         };
     }
     async install() {
+        // Nothing to do
     }
     async read(opts) {
         let items = this
             .entries;
+        // Filter
+        // Of course it handles only simple cases (eq X, is null, in) with the AND operator
         if (opts?.filters) {
             const { aggregateId, appName, name, organizationId, userId } = opts.filters;
             if (aggregateId !== undefined) {
@@ -68,6 +72,8 @@ let InMemoryUCDataStore = class InMemoryUCDataStore {
                 items = items.filter(predicate('userId', userId));
             }
         }
+        // Sort
+        // => No need, we are processing them by order of insertion in the Map
         return {
             records: items,
         };
@@ -79,6 +85,7 @@ let InMemoryUCDataStore = class InMemoryUCDataStore {
         return [];
     }
     async testKey() {
+        // Nothing to do
     }
     async write(record) {
         this.writeBulk([record]);

package/dist/esm/uc/impl/KnexUCDataStore.d.ts

@@ -5,6 +5,10 @@ import type { UCDataStore, UCDataStoreReadOpts, UCDataStoreReadProjectionOpts, U
 import type { UCData } from '../data.js';
 import type { UCInput } from '../input.js';
 import type { UCSettings } from '../settings.js';
+/**
+ * @see https://knexjs.org/guide/#configuration-options
+ * @see https://knexjs.org/guide/#pool
+ */
 export interface KnexUCDataStoreSettings extends Settings {
     knex_uc_data_store_conn_string: `postgresql://${string}`;
     knex_uc_data_store_file_path: FilePath | ':memory:';

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

@@ -58,6 +58,7 @@ let KnexUCDataStore = class KnexUCDataStore {
     }
     async read(opts) {
         const query = this.client(this.s().uc_data_store_ucs_dataset_name);
+        // Filter
         if (opts?.filters) {
             const { aggregateId, appName, idWithinInput, name, organizationId, userId, } = opts.filters;
             this.filter(query, aggregateId, 'aggregateId');
@@ -67,10 +68,17 @@ let KnexUCDataStore = class KnexUCDataStore {
             this.filter(query, userId, 'userId');
             if (idWithinInput !== undefined) {
                 for (const [k, v] of Object.entries(idWithinInput)) {
+                    // Not comfortable with the key here but it seems to escape correctly :
+                    // select * from "d2efe54a-ce85-437c-958e-440f54c0743d"
+                    //   where jsonb_path_query_first("input", ?) #>> '{}' = ?
+                    //   and "name" = ?
+                    //   and "organization_id" = ?
+                    //   order by "created_at" asc
                     query.whereJsonPath('input', `$.${k}`, '=', v);
                 }
             }
         }
+        // Sort
         query.orderBy('created_at', 'asc');
         const records = (await query).map((r) => this.mapRowToRecord(r));
         return {
@@ -79,11 +87,13 @@ let KnexUCDataStore = class KnexUCDataStore {
     }
     async readProjection(name, opts) {
         const query = this.client(name);
+        // Sort
         if (opts?.orderBy) {
             for (const [k, v] of Object.entries(opts.orderBy)) {
                 query.orderBy(k, v);
             }
         }
+        // Paginate
         if (opts?.limit) {
             query.limit(opts.limit);
         }
@@ -201,9 +211,13 @@ let KnexUCDataStore = class KnexUCDataStore {
         };
     }
     parseJSONColIfNecessary(value) {
+        // In some DBs, the json type is returned as string (e.g. sqlite3)
         return typeof value === 'string' ? JSON.parse(value) : value;
     }
+    //#region migrations
     async migration001CreateMainTable() {
+        // Using hasTable and then createTable because createTableIfNotExists has been deprecated
+        // See https://github.com/knex/knex/issues/1303#issuecomment-594489136
         const exists = await this.client.schema.hasTable(this.s().uc_data_store_ucs_dataset_name);
         if (exists) {
             return;

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

@@ -29,6 +29,7 @@ let SimpleUCManager = class SimpleUCManager {
     ucInputValidator;
     ucInitProvider;
     ucMainProvider;
+    // WARNING : This property makes this class "thread unsafe". Be careful how you inject it into your components.
     tx;
     constructor(ucClientConfirmManager, clockManager, cryptoManager, logger, ucDataStore, ucExecChecker, ucInputFilesProcessor, ucInputValidator, ucInitProvider, ucMainProvider) {
         this.ucClientConfirmManager = ucClientConfirmManager;
@@ -64,6 +65,7 @@ let SimpleUCManager = class SimpleUCManager {
         if (!client) {
             throw new Error(`The use case ${metadata.name} has no client lifecycle`);
         }
+        // Always check the right to execute, even if done when displaying the control
         const { allowed } = await this.ucExecChecker.exec({
             lifecycle: 'client',
             uc,
@@ -72,6 +74,9 @@ let SimpleUCManager = class SimpleUCManager {
             throw new ForbiddenError();
         }
         this.ucInputValidator.exec({ uc });
+        // Process the file client side only if it is not sent to the server
+        // Be careful with some edge cases where the file needs to be uploaded somewhere else.
+        // Note that we cannot check server !== true because in some cases, the server is not stripped (e.g. tests, node cli client, etc.).
         if (server === undefined) {
             await this.ucInputFilesProcessor.exec({ uc });
         }
@@ -85,6 +90,7 @@ let SimpleUCManager = class SimpleUCManager {
         if (typeof server !== 'object') {
             throw new Error(`The use case ${metadata.name} has no server lifecycle`);
         }
+        // Always check the right to execute, even if done when displaying the control
         const { allowed } = await this.ucExecChecker.exec({
             lifecycle: 'server',
             uc,