@decaf-ts/core 0.5.0 → 0.5.2

package/lib/esm/ram/RamStatement.js

@@ -1,18 +1,187 @@
-import { Statement } from "../query";
+import { GroupOperator, Operator, QueryError, } from "../query";
 import { RamPaginator } from "./RamPaginator";
 import { InternalError } from "@decaf-ts/db-decorators";
+import { Statement } from "../query/Statement";
+import { Reflection } from "@decaf-ts/reflection";
+/**
+ * @description RAM-specific query statement builder
+ * @summary Extends the base Statement class to provide query building functionality for the RAM adapter.
+ * This class translates high-level query operations into predicates that can filter and sort
+ * in-memory data structures.
+ * @template M - The model type being queried
+ * @template R - The result type returned by the query
+ * @param {RamAdapter} adapter - The RAM adapter instance to use for executing queries
+ * @class RamStatement
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a statement for querying User models
+ * const statement = new RamStatement<User, User>(ramAdapter);
+ *
+ * // Build a query to find active users with age > 18
+ * const results = await statement
+ *   .from(User)
+ *   .where(Condition.and(
+ *     Condition.eq('active', true),
+ *     Condition.gt('age', 18)
+ *   ))
+ *   .orderBy('lastName', 'asc')
+ *   .limit(10)
+ *   .execute();
+ * ```
+ */
 export class RamStatement extends Statement {
-    constructor(db) {
-        super(db);
+    constructor(adapter) {
+        super(adapter);
     }
-    paginate(size) {
+    /**
+     * @description Creates a sort comparator function
+     * @summary Generates a function that compares two model instances based on the orderBy criteria.
+     * This method handles different data types (string, number, date) and sort directions (asc, desc).
+     * @return {function(Model, Model): number} A comparator function for sorting model instances
+     */
+    getSort() {
+        return (el1, el2) => {
+            if (!this.orderBySelector)
+                throw new InternalError("orderBySelector not set. Should be impossible");
+            const selector = this.orderBySelector;
+            const [key, direction] = selector;
+            const type = Reflection.getTypeFromDecorator(el1, key);
+            if (!type)
+                throw new QueryError(`type not compatible with sorting: ${type}`);
+            switch (type) {
+                case "string":
+                case "String":
+                    return ((direction === "asc" ? 1 : -1) *
+                        el1[key].localeCompare(el2[key]));
+                case "number":
+                case "Number":
+                    return ((direction === "asc" ? 1 : -1) *
+                        (el1[key] -
+                            el2[key]));
+                case "object":
+                case "Object":
+                    if (el1[key] instanceof Date &&
+                        el2[key] instanceof Date)
+                        return ((direction === "asc" ? 1 : -1) *
+                            (el1[key].valueOf() -
+                                el2[key].valueOf()));
+                    throw new QueryError(`Sorting not supported for not date classes`);
+                default:
+                    throw new QueryError(`sorting not supported for type ${type}`);
+            }
+        };
+    }
+    /**
+     * @description Builds a RAM query from the statement
+     * @summary Converts the statement's selectors and conditions into a RawRamQuery object
+     * that can be executed by the RAM adapter. This method assembles all query components
+     * (select, from, where, limit, offset, sort) into the final query structure.
+     * @return {RawRamQuery<M>} The constructed RAM query object
+     */
+    build() {
+        const result = {
+            select: this.selectSelector,
+            from: this.fromSelector,
+            where: this.whereCondition
+                ? this.parseCondition(this.whereCondition).where
+                : // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    (el) => {
+                        return true;
+                    },
+            limit: this.limitSelector,
+            skip: this.offsetSelector,
+        };
+        if (this.orderBySelector)
+            result.sort = this.getSort();
+        return result;
+    }
+    /**
+     * @description Creates a paginator for the query
+     * @summary Builds the query and wraps it in a RamPaginator to enable pagination of results.
+     * This allows retrieving large result sets in smaller chunks.
+     * @param {number} size - The page size (number of results per page)
+     * @return {Promise<Paginator<M, R, RawRamQuery<M>>>} A promise that resolves to a paginator for the query
+     */
+    async paginate(size) {
         try {
             const query = this.build();
-            return new RamPaginator(this, size, query);
+            return new RamPaginator(this.adapter, query, size, this.fromSelector);
         }
         catch (e) {
             throw new InternalError(e);
         }
     }
+    /**
+     * @description Parses a condition into a RAM query predicate
+     * @summary Converts a Condition object into a predicate function that can be used
+     * to filter model instances in memory. This method handles both simple conditions
+     * (equals, greater than, etc.) and complex conditions with logical operators (AND, OR).
+     * @template M - The model type for the condition
+     * @param {Condition<M>} condition - The condition to parse
+     * @return {RawRamQuery<M>} A RAM query object with a where predicate function
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RamStatement
+     *   participant SimpleCondition
+     *   participant ComplexCondition
+     *
+     *   Caller->>RamStatement: parseCondition(condition)
+     *   alt Simple condition (eq, gt, lt, etc.)
+     *     RamStatement->>SimpleCondition: Extract attr1, operator, comparison
+     *     SimpleCondition-->>RamStatement: Return predicate function
+     *   else Logical operator (AND, OR)
+     *     RamStatement->>ComplexCondition: Extract nested conditions
+     *     RamStatement->>RamStatement: parseCondition(leftCondition)
+     *     RamStatement->>RamStatement: parseCondition(rightCondition)
+     *     ComplexCondition-->>RamStatement: Combine predicates with logical operator
+     *   end
+     *   RamStatement-->>Caller: Return query with where predicate
+     */
+    parseCondition(condition) {
+        return {
+            where: (m) => {
+                const { attr1, operator, comparison } = condition;
+                if ([GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(operator) === -1) {
+                    switch (operator) {
+                        case Operator.BIGGER:
+                            return m[attr1] > comparison;
+                        case Operator.BIGGER_EQ:
+                            return m[attr1] >= comparison;
+                        case Operator.DIFFERENT:
+                            return m[attr1] !== comparison;
+                        case Operator.EQUAL:
+                            return m[attr1] === comparison;
+                        case Operator.REGEXP:
+                            if (typeof m[attr1] !== "string")
+                                throw new QueryError(`Invalid regexp comparison on a non string attribute: ${m[attr1]}`);
+                            return !!m[attr1].match(new RegExp(comparison, "g"));
+                        case Operator.SMALLER:
+                            return m[attr1] < comparison;
+                        case Operator.SMALLER_EQ:
+                            return m[attr1] <= comparison;
+                        default:
+                            throw new InternalError(`Invalid operator for standard comparisons: ${operator}`);
+                    }
+                }
+                else if (operator === Operator.NOT) {
+                    throw new InternalError("Not implemented");
+                }
+                else {
+                    const op1 = this.parseCondition(attr1);
+                    const op2 = this.parseCondition(comparison);
+                    switch (operator) {
+                        case GroupOperator.AND:
+                            return op1.where(m) && op2.where(m);
+                        case GroupOperator.OR:
+                            return op1.where(m) || op2.where(m);
+                        default:
+                            throw new InternalError(`Invalid operator for And/Or comparisons: ${operator}`);
+                    }
+                }
+            },
+        };
+    }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtU3RhdGVtZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JhbS9SYW1TdGF0ZW1lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFhLFNBQVMsRUFBRSxNQUFNLFVBQVUsQ0FBQztBQUloRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDOUMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBRXhELE1BQU0sT0FBTyxZQUE4QixTQUFRLFNBQXNCO0lBQ3ZFLFlBQVksRUFBdUM7UUFDakQsS0FBSyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ1osQ0FBQztJQUVELFFBQVEsQ0FBSSxJQUFZO1FBQ3RCLElBQUksQ0FBQztZQUNILE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUMzQixPQUFPLElBQUksWUFBWSxDQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsS0FBSyxDQUFRLENBQUM7UUFDcEQsQ0FBQztRQUFDLE9BQU8sQ0FBTSxFQUFFLENBQUM7WUFDaEIsTUFBTSxJQUFJLGFBQWEsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUM3QixDQUFDO0lBQ0gsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGFnaW5hdG9yLCBTdGF0ZW1lbnQgfSBmcm9tIFwiLi4vcXVlcnlcIjtcbmltcG9ydCB7IFJhbVF1ZXJ5IH0gZnJvbSBcIi4vdHlwZXNcIjtcbmltcG9ydCB7IE1vZGVsIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuaW1wb3J0IHsgQWRhcHRlciB9IGZyb20gXCIuLi9wZXJzaXN0ZW5jZVwiO1xuaW1wb3J0IHsgUmFtUGFnaW5hdG9yIH0gZnJvbSBcIi4vUmFtUGFnaW5hdG9yXCI7XG5pbXBvcnQgeyBJbnRlcm5hbEVycm9yIH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5cbmV4cG9ydCBjbGFzcyBSYW1TdGF0ZW1lbnQ8TSBleHRlbmRzIE1vZGVsPiBleHRlbmRzIFN0YXRlbWVudDxSYW1RdWVyeTxNPj4ge1xuICBjb25zdHJ1Y3RvcihkYjogQWRhcHRlcjxhbnksIFJhbVF1ZXJ5PE0+LCBhbnksIGFueT4pIHtcbiAgICBzdXBlcihkYik7XG4gIH1cblxuICBwYWdpbmF0ZTxWPihzaXplOiBudW1iZXIpOiBQcm9taXNlPFBhZ2luYXRvcjxWLCBSYW1RdWVyeTxNPj4+IHtcbiAgICB0cnkge1xuICAgICAgY29uc3QgcXVlcnkgPSB0aGlzLmJ1aWxkKCk7XG4gICAgICByZXR1cm4gbmV3IFJhbVBhZ2luYXRvcih0aGlzLCBzaXplLCBxdWVyeSkgYXMgYW55O1xuICAgIH0gY2F0Y2ggKGU6IGFueSkge1xuICAgICAgdGhyb3cgbmV3IEludGVybmFsRXJyb3IoZSk7XG4gICAgfVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamStatement.js","sourceRoot":"","sources":["../../../src/ram/RamStatement.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Condition,\n  GroupOperator,\n  Operator,\n  Paginator,\n  QueryError,\n} from \"../query\";\nimport { RawRamQuery } from \"./types\";\nimport { Model } from \"@decaf-ts/decorator-validation\";\nimport { RamPaginator } from \"./RamPaginator\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { Statement } from \"../query/Statement\";\nimport { Reflection } from \"@decaf-ts/reflection\";\nimport { RamAdapter } from \"./RamAdapter\";\n\n/**\n * @description RAM-specific query statement builder\n * @summary Extends the base Statement class to provide query building functionality for the RAM adapter.\n * This class translates high-level query operations into predicates that can filter and sort\n * in-memory data structures.\n * @template M - The model type being queried\n * @template R - The result type returned by the query\n * @param {RamAdapter} adapter - The RAM adapter instance to use for executing queries\n * @class RamStatement\n * @category Ram\n * @example\n * ```typescript\n * // Create a statement for querying User models\n * const statement = new RamStatement<User, User>(ramAdapter);\n *\n * // Build a query to find active users with age > 18\n * const results = await statement\n *   .from(User)\n *   .where(Condition.and(\n *     Condition.eq('active', true),\n *     Condition.gt('age', 18)\n *   ))\n *   .orderBy('lastName', 'asc')\n *   .limit(10)\n *   .execute();\n * ```\n */\nexport class RamStatement<M extends Model, R> extends Statement<\n  RawRamQuery<M>,\n  M,\n  R\n> {\n  constructor(adapter: RamAdapter) {\n    super(adapter as any);\n  }\n\n  /**\n   * @description Creates a sort comparator function\n   * @summary Generates a function that compares two model instances based on the orderBy criteria.\n   * This method handles different data types (string, number, date) and sort directions (asc, desc).\n   * @return {function(Model, Model): number} A comparator function for sorting model instances\n   */\n  private getSort() {\n    return (el1: Model, el2: Model) => {\n      if (!this.orderBySelector)\n        throw new InternalError(\n          \"orderBySelector not set. Should be impossible\"\n        );\n      const selector = this.orderBySelector;\n      const [key, direction] = selector;\n      const type = Reflection.getTypeFromDecorator(el1, key as string);\n      if (!type)\n        throw new QueryError(`type not compatible with sorting: ${type}`);\n\n      switch (type) {\n        case \"string\":\n        case \"String\":\n          return (\n            (direction === \"asc\" ? 1 : -1) *\n            (el1[key as keyof Model] as unknown as string).localeCompare(\n              el2[key as keyof Model] as unknown as string\n            )\n          );\n        case \"number\":\n        case \"Number\":\n          return (\n            (direction === \"asc\" ? 1 : -1) *\n            ((el1[key as keyof Model] as unknown as number) -\n              (el2[key as keyof Model] as unknown as number))\n          );\n        case \"object\":\n        case \"Object\":\n          if (\n            el1[key as keyof Model] instanceof Date &&\n            el2[key as keyof Model] instanceof Date\n          )\n            return (\n              (direction === \"asc\" ? 1 : -1) *\n              ((el1[key as keyof Model] as unknown as Date).valueOf() -\n                (el2[key as keyof Model] as unknown as Date).valueOf())\n            );\n          throw new QueryError(`Sorting not supported for not date classes`);\n        default:\n          throw new QueryError(`sorting not supported for type ${type}`);\n      }\n    };\n  }\n\n  /**\n   * @description Builds a RAM query from the statement\n   * @summary Converts the statement's selectors and conditions into a RawRamQuery object\n   * that can be executed by the RAM adapter. This method assembles all query components\n   * (select, from, where, limit, offset, sort) into the final query structure.\n   * @return {RawRamQuery<M>} The constructed RAM query object\n   */\n  protected build(): RawRamQuery<M> {\n    const result: RawRamQuery<M> = {\n      select: this.selectSelector,\n      from: this.fromSelector,\n      where: this.whereCondition\n        ? this.parseCondition(this.whereCondition).where\n        : // eslint-disable-next-line @typescript-eslint/no-unused-vars\n          (el: M) => {\n            return true;\n          },\n      limit: this.limitSelector,\n      skip: this.offsetSelector,\n    };\n    if (this.orderBySelector) result.sort = this.getSort();\n    return result;\n  }\n\n  /**\n   * @description Creates a paginator for the query\n   * @summary Builds the query and wraps it in a RamPaginator to enable pagination of results.\n   * This allows retrieving large result sets in smaller chunks.\n   * @param {number} size - The page size (number of results per page)\n   * @return {Promise<Paginator<M, R, RawRamQuery<M>>>} A promise that resolves to a paginator for the query\n   */\n  async paginate(size: number): Promise<Paginator<M, R, RawRamQuery<M>>> {\n    try {\n      const query = this.build();\n      return new RamPaginator<M, R>(\n        this.adapter,\n        query,\n        size,\n        this.fromSelector\n      );\n    } catch (e: any) {\n      throw new InternalError(e);\n    }\n  }\n\n  /**\n   * @description Parses a condition into a RAM query predicate\n   * @summary Converts a Condition object into a predicate function that can be used\n   * to filter model instances in memory. This method handles both simple conditions\n   * (equals, greater than, etc.) and complex conditions with logical operators (AND, OR).\n   * @template M - The model type for the condition\n   * @param {Condition<M>} condition - The condition to parse\n   * @return {RawRamQuery<M>} A RAM query object with a where predicate function\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant RamStatement\n   *   participant SimpleCondition\n   *   participant ComplexCondition\n   *\n   *   Caller->>RamStatement: parseCondition(condition)\n   *   alt Simple condition (eq, gt, lt, etc.)\n   *     RamStatement->>SimpleCondition: Extract attr1, operator, comparison\n   *     SimpleCondition-->>RamStatement: Return predicate function\n   *   else Logical operator (AND, OR)\n   *     RamStatement->>ComplexCondition: Extract nested conditions\n   *     RamStatement->>RamStatement: parseCondition(leftCondition)\n   *     RamStatement->>RamStatement: parseCondition(rightCondition)\n   *     ComplexCondition-->>RamStatement: Combine predicates with logical operator\n   *   end\n   *   RamStatement-->>Caller: Return query with where predicate\n   */\n  parseCondition<M extends Model>(condition: Condition<M>): RawRamQuery<M> {\n    return {\n      where: (m: Model) => {\n        const { attr1, operator, comparison } = condition as unknown as {\n          attr1: string | Condition<M>;\n          operator: Operator | GroupOperator;\n          comparison: any;\n        };\n\n        if (\n          [GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(\n            operator as GroupOperator\n          ) === -1\n        ) {\n          switch (operator) {\n            case Operator.BIGGER:\n              return m[attr1 as keyof Model] > comparison;\n            case Operator.BIGGER_EQ:\n              return m[attr1 as keyof Model] >= comparison;\n            case Operator.DIFFERENT:\n              return m[attr1 as keyof Model] !== comparison;\n            case Operator.EQUAL:\n              return m[attr1 as keyof Model] === comparison;\n            case Operator.REGEXP:\n              if (typeof m[attr1 as keyof Model] !== \"string\")\n                throw new QueryError(\n                  `Invalid regexp comparison on a non string attribute: ${m[attr1 as keyof Model]}`\n                );\n              return !!(m[attr1 as keyof Model] as unknown as string).match(\n                new RegExp(comparison, \"g\")\n              );\n            case Operator.SMALLER:\n              return m[attr1 as keyof Model] < comparison;\n            case Operator.SMALLER_EQ:\n              return m[attr1 as keyof Model] <= comparison;\n            default:\n              throw new InternalError(\n                `Invalid operator for standard comparisons: ${operator}`\n              );\n          }\n        } else if (operator === Operator.NOT) {\n          throw new InternalError(\"Not implemented\");\n        } else {\n          const op1: RawRamQuery<any> = this.parseCondition(\n            attr1 as Condition<M>\n          );\n          const op2: RawRamQuery<any> = this.parseCondition(\n            comparison as Condition<M>\n          );\n          switch (operator) {\n            case GroupOperator.AND:\n              return op1.where(m) && op2.where(m);\n            case GroupOperator.OR:\n              return op1.where(m) || op2.where(m);\n            default:\n              throw new InternalError(\n                `Invalid operator for And/Or comparisons: ${operator}`\n              );\n          }\n        }\n      },\n    } as RawRamQuery<any>;\n  }\n}\n"]}

package/lib/esm/ram/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @description Identifier for the RAM adapter
+ * @summary A constant string that uniquely identifies the RAM adapter in the system.
+ * Used for adapter type identification and configuration.
+ * @const RamFlavour
+ * @memberOf module:core
+ * @category Ram
+ */
+export declare const RamFlavour = "ram";

package/lib/esm/ram/constants.js

@@ -0,0 +1,10 @@
+/**
+ * @description Identifier for the RAM adapter
+ * @summary A constant string that uniquely identifies the RAM adapter in the system.
+ * Used for adapter type identification and configuration.
+ * @const RamFlavour
+ * @memberOf module:core
+ * @category Ram
+ */
+export const RamFlavour = "ram";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3JhbS9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7R0FPRztBQUNILE1BQU0sQ0FBQyxNQUFNLFVBQVUsR0FBRyxLQUFLLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBkZXNjcmlwdGlvbiBJZGVudGlmaWVyIGZvciB0aGUgUkFNIGFkYXB0ZXJcbiAqIEBzdW1tYXJ5IEEgY29uc3RhbnQgc3RyaW5nIHRoYXQgdW5pcXVlbHkgaWRlbnRpZmllcyB0aGUgUkFNIGFkYXB0ZXIgaW4gdGhlIHN5c3RlbS5cbiAqIFVzZWQgZm9yIGFkYXB0ZXIgdHlwZSBpZGVudGlmaWNhdGlvbiBhbmQgY29uZmlndXJhdGlvbi5cbiAqIEBjb25zdCBSYW1GbGF2b3VyXG4gKiBAbWVtYmVyT2YgbW9kdWxlOmNvcmVcbiAqIEBjYXRlZ29yeSBSYW1cbiAqL1xuZXhwb3J0IGNvbnN0IFJhbUZsYXZvdXIgPSBcInJhbVwiO1xuIl19

package/lib/esm/ram/handlers.d.ts

@@ -0,0 +1,25 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Repo } from "../repository";
+import { RelationsMetadata } from "../model";
+import { RamFlags } from "./types";
+import { Context } from "@decaf-ts/db-decorators";
+/**
+ * @description Sets the created by field on a model during RAM create/update operations
+ * @summary Automatically populates a model field with the UUID from the context during create or update operations.
+ * This function is designed to be used as a handler for RAM operations to track entity creation.
+ * @template M - Type of the model being created/updated
+ * @template R - Type of the repository handling the model
+ * @template V - Type of the relations metadata
+ * @template F - Type of the RAM flags
+ * @template C - Type of the context
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The operation context containing user identification
+ * @param {V} data - The relations metadata
+ * @param key - The property key to set with the UUID
+ * @param {M} model - The model instance being created/updated
+ * @return {Promise<void>} A promise that resolves when the field has been set
+ * @function createdByOnRamCreateUpdate
+ * @memberOf module:core
+ * @category Ram
+ */
+export declare function createdByOnRamCreateUpdate<M extends Model, R extends Repo<M, F, C>, V extends RelationsMetadata, F extends RamFlags, C extends Context<F>>(this: R, context: Context<F>, data: V, key: keyof M, model: M): Promise<void>;

package/lib/esm/ram/handlers.js

@@ -0,0 +1,27 @@
+import { UnsupportedError } from "../persistence";
+/**
+ * @description Sets the created by field on a model during RAM create/update operations
+ * @summary Automatically populates a model field with the UUID from the context during create or update operations.
+ * This function is designed to be used as a handler for RAM operations to track entity creation.
+ * @template M - Type of the model being created/updated
+ * @template R - Type of the repository handling the model
+ * @template V - Type of the relations metadata
+ * @template F - Type of the RAM flags
+ * @template C - Type of the context
+ * @param {R} this - The repository instance
+ * @param {Context<F>} context - The operation context containing user identification
+ * @param {V} data - The relations metadata
+ * @param key - The property key to set with the UUID
+ * @param {M} model - The model instance being created/updated
+ * @return {Promise<void>} A promise that resolves when the field has been set
+ * @function createdByOnRamCreateUpdate
+ * @memberOf module:core
+ * @category Ram
+ */
+export async function createdByOnRamCreateUpdate(context, data, key, model) {
+    const uuid = context.get("UUID");
+    if (!uuid)
+        throw new UnsupportedError("This adapter does not support user identification");
+    model[key] = uuid;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/ram/index.d.ts

@@ -1,9 +1,9 @@
-export * from "./clauses";
 export * from "./model";
-export * from "./RamAdapter";
-export * from "./RamClauseFactory";
+export * from "./constants";
+export * from "./handlers";
 export * from "./RamContext";
 export * from "./RamPaginator";
-export * from "./RamSequence";
 export * from "./RamStatement";
+export * from "./RamSequence";
 export * from "./types";
+export * from "./RamAdapter";

package/lib/esm/ram/index.js

@@ -1,10 +1,14 @@
-export * from "./clauses";
+import { RamAdapter } from "./RamAdapter";
+// Invoked there to ensure decoration override
+RamAdapter.decoration();
 export * from "./model";
-export * from "./RamAdapter";
-export * from "./RamClauseFactory";
+export * from "./constants";
+export * from "./handlers";
 export * from "./RamContext";
 export * from "./RamPaginator";
-export * from "./RamSequence";
 export * from "./RamStatement";
+export * from "./RamSequence";
 export * from "./types";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmFtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsU0FBUyxDQUFDO0FBQ3hCLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vY2xhdXNlc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbW9kZWxcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbUFkYXB0ZXJcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbUNsYXVzZUZhY3RvcnlcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbUNvbnRleHRcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbVBhZ2luYXRvclwiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmFtU2VxdWVuY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbVN0YXRlbWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vdHlwZXNcIjtcbiJdfQ==
+// left to last on purpose
+export * from "./RamAdapter";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmFtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFMUMsOENBQThDO0FBQzlDLFVBQVUsQ0FBQyxVQUFVLEVBQUUsQ0FBQztBQUV4QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsMEJBQTBCO0FBQzFCLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmFtQWRhcHRlciB9IGZyb20gXCIuL1JhbUFkYXB0ZXJcIjtcblxuLy8gSW52b2tlZCB0aGVyZSB0byBlbnN1cmUgZGVjb3JhdGlvbiBvdmVycmlkZVxuUmFtQWRhcHRlci5kZWNvcmF0aW9uKCk7XG5cbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hhbmRsZXJzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SYW1Db250ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SYW1QYWdpbmF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbVN0YXRlbWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmFtU2VxdWVuY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG4vLyBsZWZ0IHRvIGxhc3Qgb24gcHVycG9zZVxuZXhwb3J0ICogZnJvbSBcIi4vUmFtQWRhcHRlclwiO1xuIl19

package/lib/esm/ram/model/RamSequence.d.ts

@@ -1,19 +1,31 @@
 import type { ModelArg } from "@decaf-ts/decorator-validation";
 import { BaseModel } from "../../model";
+/**
+ * @description RAM sequence model for auto-incrementing values
+ * @summary A model class that represents a sequence in the RAM adapter. It stores the current value
+ * of a sequence that can be used for generating sequential identifiers for entities.
+ * The sequence is identified by its ID and maintains the current value.
+ * @param {ModelArg<Sequence>} seq - Initial sequence data
+ * @class Sequence
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new sequence
+ * const orderSequence = new Sequence({ id: 'order_seq', current: 1 });
+ *
+ * // Use the sequence to get the next value
+ * const nextOrderId = parseInt(orderSequence.current.toString()) + 1;
+ * orderSequence.current = nextOrderId;
+ * ```
+ */
 export declare class Sequence extends BaseModel {
     /**
-     * @summary the Primary key for the DBSequence
-     * @prop name
-     *
-     * @see pk
+     * @description Primary key identifier for the sequence
      */
     id: string;
     /**
-     * @summary the current value for the DBSequence
-     * @prop current
-     *
-     * @see required
-     * @see index
+     * @description Current value of the sequence
+     * Used to generate the next sequential value
      */
     current: string | number;
     constructor(seq?: ModelArg<Sequence>);

package/lib/esm/ram/model/RamSequence.js

@@ -10,6 +10,24 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { model, required } from "@decaf-ts/decorator-validation";
 import { BaseModel, index, table } from "../../model";
 import { pk } from "../../identity";
+/**
+ * @description RAM sequence model for auto-incrementing values
+ * @summary A model class that represents a sequence in the RAM adapter. It stores the current value
+ * of a sequence that can be used for generating sequential identifiers for entities.
+ * The sequence is identified by its ID and maintains the current value.
+ * @param {ModelArg<Sequence>} seq - Initial sequence data
+ * @class Sequence
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new sequence
+ * const orderSequence = new Sequence({ id: 'order_seq', current: 1 });
+ *
+ * // Use the sequence to get the next value
+ * const nextOrderId = parseInt(orderSequence.current.toString()) + 1;
+ * orderSequence.current = nextOrderId;
+ * ```
+ */
 let Sequence = class Sequence extends BaseModel {
     constructor(seq) {
         super(seq);
@@ -30,4 +48,4 @@ Sequence = __decorate([
     __metadata("design:paramtypes", [Object])
 ], Sequence);
 export { Sequence };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtU2VxdWVuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcmFtL21vZGVsL1JhbVNlcXVlbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLE1BQU0sZ0NBQWdDLENBQUM7QUFFakUsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBQ3RELE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUk3QixJQUFNLFFBQVEsR0FBZCxNQUFNLFFBQVMsU0FBUSxTQUFTO0lBb0JyQyxZQUFZLEdBQXdCO1FBQ2xDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNiLENBQUM7Q0FDRixDQUFBO0FBZkM7SUFEQyxFQUFFLEVBQUU7O29DQUNPO0FBVVo7SUFGQyxRQUFRLEVBQUU7SUFDVixLQUFLLEVBQUU7O3lDQUNrQjtBQWxCZixRQUFRO0lBRnBCLEtBQUssQ0FBQyxlQUFlLENBQUM7SUFDdEIsS0FBSyxFQUFFOztHQUNLLFFBQVEsQ0F1QnBCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgbW9kZWwsIHJlcXVpcmVkIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuaW1wb3J0IHR5cGUgeyBNb2RlbEFyZyB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB7IEJhc2VNb2RlbCwgaW5kZXgsIHRhYmxlIH0gZnJvbSBcIi4uLy4uL21vZGVsXCI7XG5pbXBvcnQgeyBwayB9IGZyb20gXCIuLi8uLi9pZGVudGl0eVwiO1xuXG5AdGFibGUoXCJfX1JhbVNlcXVlbmNlXCIpXG5AbW9kZWwoKVxuZXhwb3J0IGNsYXNzIFNlcXVlbmNlIGV4dGVuZHMgQmFzZU1vZGVsIHtcbiAgLyoqXG4gICAqIEBzdW1tYXJ5IHRoZSBQcmltYXJ5IGtleSBmb3IgdGhlIERCU2VxdWVuY2VcbiAgICogQHByb3AgbmFtZVxuICAgKlxuICAgKiBAc2VlIHBrXG4gICAqL1xuICBAcGsoKVxuICBpZCE6IHN0cmluZztcbiAgLyoqXG4gICAqIEBzdW1tYXJ5IHRoZSBjdXJyZW50IHZhbHVlIGZvciB0aGUgREJTZXF1ZW5jZVxuICAgKiBAcHJvcCBjdXJyZW50XG4gICAqXG4gICAqIEBzZWUgcmVxdWlyZWRcbiAgICogQHNlZSBpbmRleFxuICAgKi9cbiAgQHJlcXVpcmVkKClcbiAgQGluZGV4KClcbiAgY3VycmVudCE6IHN0cmluZyB8IG51bWJlcjtcblxuICBjb25zdHJ1Y3RvcihzZXE/OiBNb2RlbEFyZzxTZXF1ZW5jZT4pIHtcbiAgICBzdXBlcihzZXEpO1xuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/ram/types.d.ts

@@ -2,16 +2,58 @@ import { Constructor, Model } from "@decaf-ts/decorator-validation";
 import { Repository } from "../repository";
 import { Context, RepositoryFlags } from "@decaf-ts/db-decorators";
 import { RamAdapter } from "./RamAdapter";
-export type RamStorage = Record<string, Record<string, any>>;
-export type RamQuery<M extends Model> = {
-    select: undefined | keyof M | (keyof M)[];
-    from: string | M | Constructor<M>;
+/**
+ * @description In-memory storage structure for the RAM adapter
+ * @summary A nested Map structure that stores all entities by their table name and primary key.
+ * The outer Map uses table names as keys, while the inner Map uses entity IDs as keys and entity instances as values.
+ * @typedef {Map<string, Map<string | number, any>>} RamStorage
+ * @memberOf module:core
+ * @category Ram
+ */
+export type RamStorage = Map<string, Map<string | number, any>>;
+/**
+ * @description Query specification for RAM adapter
+ * @summary Defines the structure of a query for retrieving data from the in-memory storage.
+ * It specifies what fields to select, which model to query, filtering conditions,
+ * sorting criteria, and pagination options.
+ * @template M - The model type being queried
+ * @typedef {Object} RawRamQuery
+ * @property select - Fields to select from the model, or undefined for all fields
+ * @property {Constructor<M>} from - The model constructor to query
+ * @property {function(M): boolean} where - Predicate function for filtering entities
+ * @property {function(M, M): number} [sort] - Optional comparator function for sorting results
+ * @property {number} [limit] - Optional maximum number of results to return
+ * @property {number} [skip] - Optional number of results to skip (for pagination)
+ * @memberOf module:core
+ * @category Ram
+ */
+export type RawRamQuery<M extends Model> = {
+    select: undefined | (keyof M)[];
+    from: Constructor<M>;
     where: (el: M) => boolean;
     sort?: (el: M, el2: M) => number;
     limit?: number;
     skip?: number;
 };
+/**
+ * @description Flags for RAM adapter operations
+ * @summary Interface that extends the base repository flags with RAM-specific flags.
+ * Contains user identification information needed for tracking entity creation and updates.
+ * @interface RamFlags
+ * @property {string} UUID - Unique identifier for the current user
+ * @memberOf module:core
+ * @category Ram
+ */
 export interface RamFlags extends RepositoryFlags {
     UUID: string;
 }
-export type RamRepository<M extends Model> = Repository<M, RamQuery<M>, RamAdapter, RamFlags, Context<RamFlags>>;
+/**
+ * @description Type definition for RAM-specific repository
+ * @summary A specialized repository type for working with models in the RAM adapter.
+ * It combines the model type with RAM-specific query, adapter, flags, and context types.
+ * @template M - The model type managed by the repository
+ * @typedef {Repository<M, RawRamQuery<any>, RamAdapter, RamFlags, Context<RamFlags>>} RamRepository
+ * @memberOf module:core
+ * @category Ram
+ */
+export type RamRepository<M extends Model> = Repository<M, RawRamQuery<any>, RamAdapter, RamFlags, Context<RamFlags>>;

package/lib/esm/ram/types.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmFtL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25zdHJ1Y3RvciwgTW9kZWwgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBSZXBvc2l0b3J5IH0gZnJvbSBcIi4uL3JlcG9zaXRvcnlcIjtcbmltcG9ydCB7IENvbnRleHQsIFJlcG9zaXRvcnlGbGFncyB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuaW1wb3J0IHsgUmFtQWRhcHRlciB9IGZyb20gXCIuL1JhbUFkYXB0ZXJcIjtcblxuZXhwb3J0IHR5cGUgUmFtU3RvcmFnZSA9IFJlY29yZDxzdHJpbmcsIFJlY29yZDxzdHJpbmcsIGFueT4+O1xuXG5leHBvcnQgdHlwZSBSYW1RdWVyeTxNIGV4dGVuZHMgTW9kZWw+ID0ge1xuICBzZWxlY3Q6IHVuZGVmaW5lZCB8IGtleW9mIE0gfCAoa2V5b2YgTSlbXTtcbiAgZnJvbTogc3RyaW5nIHwgTSB8IENvbnN0cnVjdG9yPE0+O1xuICB3aGVyZTogKGVsOiBNKSA9PiBib29sZWFuO1xuICBzb3J0PzogKGVsOiBNLCBlbDI6IE0pID0+IG51bWJlcjtcbiAgbGltaXQ/OiBudW1iZXI7XG4gIHNraXA/OiBudW1iZXI7XG59O1xuXG5leHBvcnQgaW50ZXJmYWNlIFJhbUZsYWdzIGV4dGVuZHMgUmVwb3NpdG9yeUZsYWdzIHtcbiAgVVVJRDogc3RyaW5nO1xufVxuXG5leHBvcnQgdHlwZSBSYW1SZXBvc2l0b3J5PE0gZXh0ZW5kcyBNb2RlbD4gPSBSZXBvc2l0b3J5PFxuICBNLFxuICBSYW1RdWVyeTxNPixcbiAgUmFtQWRhcHRlcixcbiAgUmFtRmxhZ3MsXG4gIENvbnRleHQ8UmFtRmxhZ3M+XG4+O1xuIl19
+//# sourceMappingURL=data:application/json;base64,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