libmodulor 0.4.0 → 0.6.0

package/dist/esm/uc/input-field.d.ts

@@ -2,30 +2,90 @@ import type { DataType, TBase, UIntQuantity } from '../dt/index.js';
 import type { UCFieldKey } from './def.js';
 import type { Value } from './value.js';
 export declare enum UCInputFieldChangeOperator {
+    /**
+     * Considering the cardinality of the field (min > 1), add a new value
+     */
     ADD = "ADD",
+    /**
+     * Considering the cardinality of the field (min > 1), remove a value
+     */
     REMOVE = "REMOVE",
+    /**
+     * Reset the value of the field
+     */
     RESET = "RESET",
+    /**
+     * Considering the cardinality of the field (max <= 1), set the value
+     */
     SET = "SET"
 }
 export declare enum UCInputFieldFillingMode {
+    /**
+     * Set programmatically on behalf of the user (e.g. a foreign key id for a given object)
+     */
     AUTO_PRE = "AUTO_PRE",
+    /**
+     * Set manually by the user (e.g. a form field, a cli flag, etc.)
+     */
     MANUAL = "MANUAL"
 }
 export interface UCInputFieldDefCardinality {
     max?: UIntQuantity;
     min?: UIntQuantity;
 }
+/**
+ * Definition of a use case input field
+ */
 export interface UCInputFieldDef<T extends DataType> {
+    /**
+     * A field can have 0, 1 or n values. This field defines the rules.
+     *
+     * @defaultValue { max: 1, min: 1 } => the user must absolutely provide one value only
+     *
+     * @example { max: 5, min: 0 } => the user must provide at most 5 values or none
+     * @example { min: 0 } => the user must provide 0 values or none
+     */
     cardinality?: UCInputFieldDefCardinality;
+    /**
+     * @defaultValue {@link UCInputFieldFillingMode.MANUAL}
+     */
     fillingMode?: UCInputFieldFillingMode;
+    /**
+     * @defaultValue false
+     */
     readOnly?: boolean;
+    /**
+     * Some types are automatically considered sensitive (e.g. {@link Password}).
+     *
+     * But you can force the behavior with this setting for any other type of field.
+     *
+     * @defaultValue false
+     */
     sensitive?: boolean;
+    /**
+     * When you persist a use case, all the input fields are automatically persisted as well.
+     *
+     * Sometimes this is not wanted. Setting the field as transient will exclude it from being persisted.
+     *
+     * @defaultValue false
+     */
     transient?: boolean;
     type: TBase<T>;
 }
 export type UCInputFieldValue<T extends DataType> = Value<T>;
 export declare function ucifExamples<T extends DataType>(def: UCInputFieldDef<T>): T[] | undefined;
 export declare function ucifHint<T extends DataType>(def: UCInputFieldDef<T>): string | undefined;
+/**
+ * The unique id associated to this field
+ *
+ * By default it would return `inputfield-myField`.
+ * If you have the same field multiple times in one context (e.g. a web page), pass a unique element to the `prefix`.
+ * For example `uc1-inputfield-myField` and `uc2-inputfield-myField`
+ *
+ * @param prefix
+ * @param separator
+ * @returns
+ */
 export declare function ucifId(key: UCFieldKey, prefix?: string, separator?: string): string;
 export declare function ucifIsMandatory<T extends DataType>(def: UCInputFieldDef<T>): boolean;
 export declare function ucifRepeatability<T extends DataType>(def: UCInputFieldDef<T>): [boolean, UIntQuantity];

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

@@ -1,21 +1,41 @@
 export var UCInputFieldChangeOperator;
 (function (UCInputFieldChangeOperator) {
+    /**
+     * Considering the cardinality of the field (min > 1), add a new value
+     */
     UCInputFieldChangeOperator["ADD"] = "ADD";
+    /**
+     * Considering the cardinality of the field (min > 1), remove a value
+     */
     UCInputFieldChangeOperator["REMOVE"] = "REMOVE";
+    /**
+     * Reset the value of the field
+     */
     UCInputFieldChangeOperator["RESET"] = "RESET";
+    /**
+     * Considering the cardinality of the field (max <= 1), set the value
+     */
     UCInputFieldChangeOperator["SET"] = "SET";
 })(UCInputFieldChangeOperator || (UCInputFieldChangeOperator = {}));
 export var UCInputFieldFillingMode;
 (function (UCInputFieldFillingMode) {
+    /**
+     * Set programmatically on behalf of the user (e.g. a foreign key id for a given object)
+     */
     UCInputFieldFillingMode["AUTO_PRE"] = "AUTO_PRE";
+    /**
+     * Set manually by the user (e.g. a form field, a cli flag, etc.)
+     */
     UCInputFieldFillingMode["MANUAL"] = "MANUAL";
 })(UCInputFieldFillingMode || (UCInputFieldFillingMode = {}));
 export function ucifExamples(def) {
     const { type } = def;
     const examples = type.getExamples();
+    // Leaving the value `undefined` means you want the default value
     if (examples === undefined) {
         return [type.example()];
     }
+    // Setting the examples to `[]` means you don't want them
     if (examples.length === 0) {
         return undefined;
     }
@@ -37,6 +57,17 @@ export function ucifHint(def) {
     }
     return examples.join(', ');
 }
+/**
+ * The unique id associated to this field
+ *
+ * By default it would return `inputfield-myField`.
+ * If you have the same field multiple times in one context (e.g. a web page), pass a unique element to the `prefix`.
+ * For example `uc1-inputfield-myField` and `uc2-inputfield-myField`
+ *
+ * @param prefix
+ * @param separator
+ * @returns
+ */
 export function ucifId(key, prefix = 'inputfield', separator = '-') {
     return `${prefix}${separator}${key}`;
 }
@@ -60,12 +91,14 @@ export function ucifIsSensitive(def) {
 }
 export function ucifMustBeFilledManually(def, opts) {
     const { fillingMode } = def;
+    // If there is no mode, we consider it as UCInputFieldFillingMode.MANUAL
     if (!fillingMode) {
         return true;
     }
     const fillingModes = [
         UCInputFieldFillingMode.MANUAL,
     ];
+    // If there is no context, it means that the field cannot be set via UCInputFieldFillingMode.AUTO_PRE (e.g. in CLI target)
     if (opts?.noContext) {
         fillingModes.push(UCInputFieldFillingMode.AUTO_PRE);
     }

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

@@ -1,11 +1,35 @@
 import type { StringKeys } from '../utils/index.js';
 import type { UCInputFieldDef } from './input-field.js';
+/**
+ * Base interface all the use case input interfaces must extend
+ */
 export interface UCInput {
 }
+/**
+ * Definition of a use case input
+ */
 export interface UCInputDef<I extends UCInput> {
+    /**
+     * This is useful when you want to render a given field only after its dependent fields have been set.
+     */
     dependencies?: Partial<Record<StringKeys<I>, StringKeys<I>[]>>;
+    /**
+     * It must follow strictly the shape of the corresponding {@link UCInput} with fields sorted alphabetically.
+     */
     fields: Record<StringKeys<I>, UCInputFieldDef<any>>;
+    /**
+     * By default, the fields are displayed in the same order as in {@link fields} (i.e. alphabetically).
+     *
+     * You can customize this by specifying the desired order here.
+     *
+     * For example, when rendering a form, this is used.
+     */
     order?: StringKeys<I>[];
+    /**
+     * Cross-field validation rules
+     *
+     * For example, if you want the user to provide `a` OR `b` but not both.
+     */
     validation?: {
         or?: StringKeys<I>[];
     };

package/dist/esm/uc/lifecycle/client/IdleClientMain.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { injectable } from 'inversify';
 let IdleClientMain = class IdleClientMain {
     async exec(_props) {
+        // NOOP
     }
 };
 IdleClientMain = __decorate([

package/dist/esm/uc/lifecycle/server/IdleServerMain.js

@@ -7,6 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { injectable } from 'inversify';
 let IdleServerMain = class IdleServerMain {
     async exec(_props) {
+        // Right now it's the same as IdleClientMain, but it's better to have 2 impls in case they need to diverge
+        // NOOP
     }
 };
 IdleServerMain = __decorate([

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

@@ -8,8 +8,19 @@ import type { UCInput } from './input.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCOutputOrNothing } from './output.js';
 export interface UCManagerPersistOpts {
+    /**
+     * In case the use case relates to an existing aggregate, pass its `aggregateId` in this field.
+     * This is typically used in a `Delete` use case in order to link it to the `Create` one executed in the past.
+     */
     aggregateId?: UUID;
+    /**
+     * @defaultValue {@link UCExecMode.USER}
+     */
     executionMode?: UCExecMode;
+    /**
+     * In case the use case is performed by an anonymous user or a user outside the organization, pass the actual `organizationId` in this field.
+     * This is typically used in a use case where someone anonymous posts something for a specific organization in a multi-tenant architecture.
+     */
     organizationId?: UUID;
 }
 export interface UCManager {

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

@@ -1,8 +1,18 @@
 import type { AppName } from '../app/index.js';
 import type { IconCode } from '../icon/index.js';
+/**
+ * The type of action the use case performs
+ *
+ * This impacts the HTTP verb used in the transport layer for example.
+ */
 export type UCAction = 'Create' | 'Delete' | 'List' | 'Search' | 'Update' | 'View';
 export type UCName = Capitalize<string>;
 export type FQUCNameSeparator = '_';
+/**
+ * Fully qualified use case name
+ *
+ * It's made with the {@link AppName} and the {@link UCName} linked by {@link FQUCNameSeparator}.
+ */
 export type FQUCName = `${AppName}${FQUCNameSeparator}${UCName}`;
 export interface UCMetadata {
     action: UCAction;

package/dist/esm/uc/opi-layout.d.ts

@@ -7,6 +7,9 @@ export interface UCOPILayoutContext {
     availableWidthInPx: UIntQuantity;
     target: 'cli' | 'mobile' | 'web';
 }
+/**
+ * @alpha This feature is not fully ready yet.
+ */
 export type UCOPILayout<OPI extends UCOPIBase, LT extends UCOPILayoutType = UCOPILayoutType, LI extends UCOPILayoutInput = UCOPILayoutInput> = {
     get: (item: OPI, context: UCOPILayoutContext) => LI;
     type: LT;

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

@@ -1,6 +1,14 @@
 import type { DataType, UUID } from '../dt/index.js';
 import type { Value } from './value.js';
+/**
+ * Base interface all the use case OPI interfaces must extend
+ */
 export interface UCOPIBase {
     id: UUID;
 }
+/**
+ * A value returned as part of an OPI
+ *
+ * Unlike {@link UCInputFieldValue}, it cannot be `undefined` because it is not serializable in JSON.
+ */
 export type UCOPIValue<T extends DataType> = Exclude<Value<T>, undefined>;

package/dist/esm/uc/output-field.d.ts

@@ -1,8 +1,17 @@
 import type { DataType, TBase } from '../dt/index.js';
 import type { StringKeys } from '../utils/index.js';
 import type { UCOPIBase } from './opi.js';
+/**
+ * Definition of a use case output field
+ */
 export interface UCOutputFieldDef<OPI extends UCOPIBase, T extends DataType> {
+    /**
+     * Indicates another field of the output this field can potentially link to (in the `<a></a>` way).
+     */
     linksTo?: StringKeys<OPI>;
+    /**
+     * The aggregation method to use to present the summary of this field across all the corresponding items.
+     */
     totalType?: 'sum';
     type: TBase<T>;
 }

package/dist/esm/uc/output-part.d.ts

@@ -6,14 +6,36 @@ import type { UCOPILayout } from './opi-layout.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCOutputFieldDef } from './output-field.js';
 export interface UCOutputPart<OPI extends UCOPIBase> {
+    /**
+     * The items making the part
+     */
     items: OPI[];
+    /**
+     * Pagination to pass to the next call of the use case.
+     */
     pagination?: ListInput;
+    /**
+     * The total number of items regardless pagination.
+     */
     total: UIntQuantity;
 }
 export type UCOutputPartDefFields<OPI extends UCOPIBase> = Record<StringKeys<OPI>, UCOutputFieldDef<OPI, any>>;
+/**
+ * Definition of a use case output part
+ */
 export interface UCOutputPartDef<OPI extends UCOPIBase> {
+    /**
+     * It must follow strictly the shape of the corresponding {@link UCOPIBase} with fields sorted alphabetically.
+     */
     fields: Omit<UCOutputPartDefFields<OPI>, 'id'>;
     layout?: UCOPILayout<OPI>;
+    /**
+     * By default, the fields are displayed in the same order as in {@link fields} (i.e. alphabetically).
+     *
+     * You can customize this by specifying the desired order here.
+     *
+     * For example, when rendering a card with the data, this is used.
+     */
     order?: StringKeys<OPI>[];
     related?: {
         global: UCDef<any, any, any>[];

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

@@ -10,6 +10,9 @@ export interface UCOutput<OPI0 extends UCOPIBase | undefined = undefined, OPI1 e
     };
 }
 export type UCOutputOrNothing<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCOutput<OPI0, OPI1> | void;
+/**
+ * Definition of a use case output
+ */
 export interface UCOutputDef<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
     parts?: {
         _0: UCOutputPartDef<NonNullable<OPI0>>;

package/dist/esm/uc/policies/RoleRegularUCPolicy.js

@@ -12,6 +12,7 @@ let RoleRegularUCPolicy = class RoleRegularUCPolicy {
     }
     async exec({ uc, }) {
         const out = defaultUCPolicyOutput();
+        // Note that this excludes admin as policies have no hierarchy.
         out.allowed = uc.auth?.role === 'regular';
         return out;
     }

package/dist/esm/uc/policies/funcs.js

@@ -1,5 +1,6 @@
 export function defaultUCPolicyOutput() {
     const out = {
+        // The stricter, the better for security
         allowed: false,
     };
     return out;

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

@@ -8,6 +8,28 @@ export interface UCPolicyInput<I extends UCInput | undefined = undefined, OPI0 e
 export interface UCPolicyOutput {
     allowed: boolean;
 }
+/**
+ * The policy defines the type(s) of user(s) who can perform the use case
+ *
+ * It corresponds more or less to RBAC (Resource Based Access Control).
+ *
+ * At this moment, for simplicity, ABAC (Attribute Based Access Control) must be done in the `main` of a use case.
+ * For example, if you have to check that a user must be the owner of a resource.
+ *
+ * The main reason for this choice at this moment, is to avoid "double-fetching" in the `policy` and in `main`.
+ *   1. Fetch the resource (e.g. by id) to check if the user is the owner => Accept
+ *   2. Fetch the resource again to perform actions on it
+ *
+ * A good solution for this would be to pass the resources fetched from the `policy` to `main` but that is,
+ * at least for the moment, out of scope.
+ */
 export interface UCPolicy<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> extends Worker<UCPolicyInput<I, OPI0, OPI1>, Promise<UCPolicyOutput>> {
+    /**
+     * Determines whether the policy check can be executed before checking the auth
+     *
+     * For example, for {@link NobodyUCPolicy}, we know that there is no need to check the auth,
+     * as the policy will always return false. The same goes for {@link EverybodyUCPolicy} but
+     * in the opposite way.
+     */
     canBeExecutedPreAuth(): Promise<boolean>;
 }

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

@@ -1,6 +1,15 @@
 export type UCSecAuthType = 'apiKey' | 'basic' | 'jwt';
 export type UCSecPublicApiKeyCheckType = 'off' | 'on';
+/**
+ * Definition of the security scheme of a use case
+ */
 export interface UCSec {
+    /**
+     * @defaultValue {@link DEFAULT_UC_SEC_AT}
+     */
     authType?: UCSecAuthType;
+    /**
+     * @defaultValue {@link DEFAULT_UC_SEC_PAKCT}
+     */
     publicApiKeyCheckType?: UCSecPublicApiKeyCheckType;
 }

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

@@ -6,7 +6,17 @@ import type { UCMain } from './main.js';
 import type { UCOPIBase } from './opi.js';
 import type { UCPolicy } from './policy.js';
 export interface UCServerDef<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    /**
+     * Define how the use case can be executed
+     *
+     * When set to {@link UCExecMode.AUTO}, the use case is not mounted on the target (i.e. no endpoint on a server).
+     *
+     * @defaultValue {@link UCExecMode.USER}
+     */
     execMode?: UCExecMode;
+    /**
+     * Routine to run when mounting the use case in a {@link ServerManager}
+     */
     init?: Class<UCInit>;
     main: Class<UCMain<I, OPI0, OPI1>>;
     policy: Class<UCPolicy<I, OPI0, OPI1>>;

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

@@ -4,8 +4,33 @@ import type { UCDataStoreDatasetName } from './data-store.js';
 import type { UCFileInputFieldRefPrefix } from './file.js';
 import type { UCName } from './metadata.js';
 export interface UCSettings extends Settings {
+    /**
+     * The name of the collection/table storing the persisted use cases in the data store
+     *
+     * @default UC_DEFAULT_SETTINGS.uc_data_store_ucs_dataset_name
+     */
     uc_data_store_ucs_dataset_name: UCDataStoreDatasetName;
+    /**
+     * The list of disabled use cases (see {@link UCExecChecker})
+     *
+     * This should be used only in specific cases (e.g. disabling in emergency a use case in production).
+     *
+     * If you want a feature-flag like mechanism, chances are you need a dedicated setting, "wrapping" multiple use cases.
+     *
+     * @default UC_DEFAULT_SETTINGS.uc_disabled_use_cases
+     */
     uc_disabled_use_cases: UCName[];
+    /**
+     * The prefix of the file path when the use case has been processed, before storing
+     * @default UC_DEFAULT_SETTINGS.uc_file_ref_prefix
+     */
     uc_file_ref_prefix: UCFileInputFieldRefPrefix;
+    /**
+     * The directory path where the use case input files are copied after being processed
+     *
+     * In the future, we can imagine storing in other types of storage (e.g. S3-like).
+     *
+     * @default UC_DEFAULT_SETTINGS.uc_files_directory_path
+     */
     uc_files_directory_path: FilePath;
 }

package/dist/esm/uc/side-effect.d.ts

@@ -1,6 +1,22 @@
 export declare enum UCOutputSideEffectType {
+    /**
+     * Trigger a clearing of the auth on the calling system (e.g. `SignOut`).
+     */
     CLEAR_AUTH = "CLEAR_AUTH",
+    /**
+     * Trigger a redirect on the calling system (e.g. after the final round of an OAuth1 flow)
+     *
+     * NOTE : This is a "final" side effects, which means it must be the last one in the array of side effects.
+     * Indeed, in most servers, once you redirect, you cannot do more with the `req`/`res` (e.g. on `express`).
+     *
+     * It expects a field `redirect: URL` in `output.parts._0.items[0]`.
+     */
     REDIRECT = "REDIRECT",
+    /**
+     * Trigger a setting of the auth on the calling system (e.g. `SignIn` / `SignUp`).
+     *
+     * It expects a field `jwt: JWT` in `output.parts._0.items[0]`.
+     */
     SET_AUTH = "SET_AUTH"
 }
 export type UCOutputSideEffect = {

package/dist/esm/uc/side-effect.js

@@ -1,6 +1,22 @@
 export var UCOutputSideEffectType;
 (function (UCOutputSideEffectType) {
+    /**
+     * Trigger a clearing of the auth on the calling system (e.g. `SignOut`).
+     */
     UCOutputSideEffectType["CLEAR_AUTH"] = "CLEAR_AUTH";
+    /**
+     * Trigger a redirect on the calling system (e.g. after the final round of an OAuth1 flow)
+     *
+     * NOTE : This is a "final" side effects, which means it must be the last one in the array of side effects.
+     * Indeed, in most servers, once you redirect, you cannot do more with the `req`/`res` (e.g. on `express`).
+     *
+     * It expects a field `redirect: URL` in `output.parts._0.items[0]`.
+     */
     UCOutputSideEffectType["REDIRECT"] = "REDIRECT";
+    /**
+     * Trigger a setting of the auth on the calling system (e.g. `SignIn` / `SignUp`).
+     *
+     * It expects a field `jwt: JWT` in `output.parts._0.items[0]`.
+     */
     UCOutputSideEffectType["SET_AUTH"] = "SET_AUTH";
 })(UCOutputSideEffectType || (UCOutputSideEffectType = {}));

package/dist/esm/uc/utils/rInput.d.ts

@@ -2,9 +2,21 @@ import type { UC } from '../UC.js';
 import type { UCInput } from '../input.js';
 import type { UCOPIBase } from '../opi.js';
 interface Opts {
+    /**
+     * @defaultValue false
+     */
     forceArrayAsEmpty?: boolean | undefined;
+    /**
+     * @defaultValue true
+     */
     forceBooleanAsFalse?: boolean | undefined;
+    /**
+     * @defaultValue false
+     */
     ignoreTransient?: boolean | undefined;
+    /**
+     * @defaultValue false
+     */
     ignoreUndefined?: boolean | undefined;
 }
 export declare function rInput<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, opts?: Opts): NonNullable<I>;

package/dist/esm/uc/utils/rInput.js

@@ -32,6 +32,8 @@ export function rInput(uc, opts) {
             value = [];
         }
         if (!ignoreUndefined || (ignoreUndefined && value !== undefined)) {
+            // Useful when we get the input before persisting for example.
+            // Otherwise it will persist `undefined` as a string in the database, for nothing.
             input[f.key] = value;
         }
     }

package/dist/esm/uc/utils/rVal.d.ts

@@ -1,5 +1,30 @@
 import type { DataType } from '../../dt/index.js';
 import type { Value } from '../value.js';
+/**
+ * Read the value as a primitive
+ *
+ * To be used when the field has a 0..1 cardinality.
+ *
+ * @param value
+ * @param or
+ * @returns
+ */
 export declare function rVal0<T extends DataType>(value: Value<T>, or?: T): T | null;
+/**
+ * Require the value as a primitive
+ *
+ * To be used when the field has a 1..1 cardinality.
+ *
+ * @param value
+ * @returns
+ */
 export declare function reqVal0<T extends DataType>(value: Value<T>): T;
+/**
+ * Get the value as an array
+ *
+ * To be used when the field has a 0..* cardinality.
+ *
+ * @param value
+ * @returns
+ */
 export declare function rValArr<T extends DataType>(value: Value<T>): T[];

package/dist/esm/uc/utils/rVal.js

@@ -1,10 +1,29 @@
 import { isBlank } from '../../utils/index.js';
+// NOTE : the "r" prefix stands for "read" and the "req" prefix stands for "require"
+/**
+ * Read the value as a primitive
+ *
+ * To be used when the field has a 0..1 cardinality.
+ *
+ * @param value
+ * @param or
+ * @returns
+ */
+// TODO : Find a way to return `T` when `or` is set (function override does not work)
 export function rVal0(value, or) {
     if (isBlank(value)) {
         return or ?? null;
     }
     return Array.isArray(value) ? (value[0] ?? null) : value;
 }
+/**
+ * Require the value as a primitive
+ *
+ * To be used when the field has a 1..1 cardinality.
+ *
+ * @param value
+ * @returns
+ */
 export function reqVal0(value) {
     const val = rVal0(value);
     if (isBlank(val)) {
@@ -12,6 +31,14 @@ export function reqVal0(value) {
     }
     return val;
 }
+/**
+ * Get the value as an array
+ *
+ * To be used when the field has a 0..* cardinality.
+ *
+ * @param value
+ * @returns
+ */
 export function rValArr(value) {
     if (isBlank(value)) {
         return [];

package/dist/esm/uc/utils/recIs.d.ts

@@ -2,4 +2,13 @@ import type { UCDataStoreRecord } from '../data-store.js';
 import type { UCData } from '../data.js';
 import type { UCInput } from '../input.js';
 import type { UCName } from '../metadata.js';
+/**
+ * Check whether a data store records corresponds to the passed type
+ *
+ * Useful when fetching multiple records at once and looping over them to build an aggregate
+ *
+ * @param rec
+ * @param name
+ * @returns
+ */
 export declare const recIs: <I extends UCInput | undefined = undefined, D extends UCData | null = null>(rec: UCDataStoreRecord<any, any>, name: UCName) => rec is UCDataStoreRecord<I, D>;

package/dist/esm/uc/utils/recIs.js

@@ -1 +1,12 @@
-export const recIs = (rec, name) => rec.name === name;
+/**
+ * Check whether a data store records corresponds to the passed type
+ *
+ * Useful when fetching multiple records at once and looping over them to build an aggregate
+ *
+ * @param rec
+ * @param name
+ * @returns
+ */
+export const recIs = (
+// biome-ignore lint/suspicious/noExplicitAny: can be anything
+rec, name) => rec.name === name;