@decaf-ts/core 0.5.1 → 0.5.2

package/lib/ram/RamSequence.cjs

@@ -5,11 +5,43 @@ const RamSequence_1 = require("./model/RamSequence.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const persistence_1 = require("./../persistence/index.cjs");
 const repository_1 = require("./../repository/index.cjs");
+/**
+ * @description RAM-specific sequence implementation
+ * @summary Extends the base Sequence class to provide auto-incrementing sequence functionality
+ * for the RAM adapter. This class manages sequences stored in memory, allowing for the generation
+ * of sequential identifiers for entities.
+ * @param {SequenceOptions} options - Configuration options for the sequence
+ * @param {RamAdapter} adapter - The RAM adapter instance to use for storage
+ * @class RamSequence
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new numeric sequence starting at 1
+ * const sequence = new RamSequence({
+ *   name: 'order_sequence',
+ *   type: 'Number',
+ *   startWith: 1,
+ *   incrementBy: 1
+ * }, ramAdapter);
+ *
+ * // Get the next value in the sequence
+ * const nextId = await sequence.next();
+ *
+ * // Get a range of values
+ * const idRange = await sequence.range(5); // Returns 5 sequential values
+ * ```
+ */
 class RamSequence extends persistence_1.Sequence {
     constructor(options, adapter) {
         super(options);
-        this.repo = repository_1.Repository.forModel(RamSequence_1.Sequence, adapter.flavour);
+        this.repo = repository_1.Repository.forModel(RamSequence_1.Sequence, adapter.alias);
     }
+    /**
+     * @description Retrieves the current value of the sequence
+     * @summary Gets the current value of the sequence from storage. If the sequence
+     * doesn't exist yet, it returns the configured starting value.
+     * @return A promise that resolves to the current sequence value
+     */
     async current() {
         const { name, startWith } = this.options;
         try {
@@ -30,9 +62,24 @@ class RamSequence extends persistence_1.Sequence {
             throw new db_decorators_1.InternalError(`Failed to retrieve current value for sequence ${name}: ${e}`);
         }
     }
+    /**
+     * @description Parses a value according to the sequence type
+     * @summary Converts a value to the appropriate type for the sequence (string, number, or bigint)
+     * using the base Sequence class's parseValue method.
+     * @param {string | number | bigint} value - The value to parse
+     * @return {string | number | bigint} The parsed value in the correct type
+     */
     parse(value) {
         return persistence_1.Sequence.parseValue(this.options.type, value);
     }
+    /**
+     * @description Increments the sequence value
+     * @summary Increases the current sequence value by the specified amount and persists
+     * the new value to storage. This method handles both numeric and BigInt sequence types.
+     * @param {string | number | bigint} current - The current value of the sequence
+     * @param {number} [count] - Optional amount to increment by, defaults to the sequence's incrementBy value
+     * @return A promise that resolves to the new sequence value after incrementing
+     */
     async increment(current, count) {
         const { type, incrementBy, name } = this.options;
         let next;
@@ -64,10 +111,24 @@ class RamSequence extends persistence_1.Sequence {
         }
         return seq.current;
     }
+    /**
+     * @description Gets the next value in the sequence
+     * @summary Retrieves the current value of the sequence and increments it by the
+     * configured increment amount. This is the main method used to get a new sequential value.
+     * @return A promise that resolves to the next value in the sequence
+     */
     async next() {
         const current = await this.current();
         return this.increment(current);
     }
+    /**
+     * @description Generates a range of sequential values
+     * @summary Retrieves a specified number of sequential values from the sequence.
+     * This is useful when you need to allocate multiple IDs at once.
+     * The method increments the sequence by the total amount needed and returns all values in the range.
+     * @param {number} count - The number of sequential values to generate
+     * @return A promise that resolves to an array of sequential values
+     */
     async range(count) {
         const current = (await this.current());
         const incrementBy = this.parse(this.options.incrementBy);
@@ -82,4 +143,4 @@ class RamSequence extends persistence_1.Sequence {
     }
 }
 exports.RamSequence = RamSequence;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamSequence.js","sourceRoot":"","sources":["../../src/ram/RamSequence.ts"],"names":[],"mappings":"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","sourcesContent":["import { Sequence as Seq } from \"./model/RamSequence\";\nimport { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { Sequence } from \"../persistence\";\nimport { SequenceOptions } from \"../interfaces\";\nimport { RamAdapter } from \"./RamAdapter\";\nimport { Repo, Repository } from \"../repository\";\n\nexport class RamSequence extends Sequence {\n  protected repo: Repo<Seq>;\n\n  constructor(options: SequenceOptions, adapter: RamAdapter) {\n    super(options);\n    this.repo = Repository.forModel(Seq, adapter.flavour);\n  }\n\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: any) {\n          throw new InternalError(\n            `Failed to parse initial value for sequence ${startWith}: ${e}`\n          );\n        }\n      }\n      throw new InternalError(\n        `Failed to retrieve current value for sequence ${name}: ${e}`\n      );\n    }\n  }\n\n  private parse(value: string | number | bigint): string | number | bigint {\n    return Sequence.parseValue(this.options.type, value);\n  }\n\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    const repo = this.repo.override({\n      ignoredValidationProperties: [\"updatedOn\"],\n    });\n    try {\n      seq = await repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) {\n        throw e;\n      }\n      seq = await repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamSequence.js","sourceRoot":"","sources":["../../src/ram/RamSequence.ts"],"names":[],"mappings":"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","sourcesContent":["import { Sequence as Seq } from \"./model/RamSequence\";\nimport { InternalError, NotFoundError } from \"@decaf-ts/db-decorators\";\nimport { Sequence } from \"../persistence\";\nimport { SequenceOptions } from \"../interfaces\";\nimport { RamAdapter } from \"./RamAdapter\";\nimport { Repo, Repository } from \"../repository\";\n\n/**\n * @description RAM-specific sequence implementation\n * @summary Extends the base Sequence class to provide auto-incrementing sequence functionality\n * for the RAM adapter. This class manages sequences stored in memory, allowing for the generation\n * of sequential identifiers for entities.\n * @param {SequenceOptions} options - Configuration options for the sequence\n * @param {RamAdapter} adapter - The RAM adapter instance to use for storage\n * @class RamSequence\n * @category Ram\n * @example\n * ```typescript\n * // Create a new numeric sequence starting at 1\n * const sequence = new RamSequence({\n *   name: 'order_sequence',\n *   type: 'Number',\n *   startWith: 1,\n *   incrementBy: 1\n * }, ramAdapter);\n *\n * // Get the next value in the sequence\n * const nextId = await sequence.next();\n *\n * // Get a range of values\n * const idRange = await sequence.range(5); // Returns 5 sequential values\n * ```\n */\nexport class RamSequence extends Sequence {\n  protected repo: Repo<Seq>;\n\n  constructor(options: SequenceOptions, adapter: RamAdapter) {\n    super(options);\n    this.repo = Repository.forModel(Seq, adapter.alias);\n  }\n\n  /**\n   * @description Retrieves the current value of the sequence\n   * @summary Gets the current value of the sequence from storage. If the sequence\n   * doesn't exist yet, it returns the configured starting value.\n   * @return A promise that resolves to the current sequence value\n   */\n  async current(): Promise<string | number | bigint> {\n    const { name, startWith } = this.options;\n    try {\n      const sequence: Seq = await this.repo.read(name as string);\n      return this.parse(sequence.current as string | number);\n    } catch (e: any) {\n      if (e instanceof NotFoundError) {\n        if (typeof startWith === \"undefined\")\n          throw new InternalError(\n            \"Starting value is not defined for a non existing sequence\"\n          );\n        try {\n          return this.parse(startWith);\n        } catch (e: any) {\n          throw new InternalError(\n            `Failed to parse initial value for sequence ${startWith}: ${e}`\n          );\n        }\n      }\n      throw new InternalError(\n        `Failed to retrieve current value for sequence ${name}: ${e}`\n      );\n    }\n  }\n\n  /**\n   * @description Parses a value according to the sequence type\n   * @summary Converts a value to the appropriate type for the sequence (string, number, or bigint)\n   * using the base Sequence class's parseValue method.\n   * @param {string | number | bigint} value - The value to parse\n   * @return {string | number | bigint} The parsed value in the correct type\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return Sequence.parseValue(this.options.type, value);\n  }\n\n  /**\n   * @description Increments the sequence value\n   * @summary Increases the current sequence value by the specified amount and persists\n   * the new value to storage. This method handles both numeric and BigInt sequence types.\n   * @param {string | number | bigint} current - The current value of the sequence\n   * @param {number} [count] - Optional amount to increment by, defaults to the sequence's incrementBy value\n   * @return A promise that resolves to the new sequence value after incrementing\n   */\n  private async increment(\n    current: string | number | bigint,\n    count?: number\n  ): Promise<string | number | bigint> {\n    const { type, incrementBy, name } = this.options;\n    let next: string | number | bigint;\n    const toIncrementBy = count || incrementBy;\n    if (toIncrementBy % incrementBy !== 0)\n      throw new InternalError(\n        `Value to increment does not consider the incrementBy setting: ${incrementBy}`\n      );\n    switch (type) {\n      case \"Number\":\n        next = (this.parse(current) as number) + toIncrementBy;\n        break;\n      case \"BigInt\":\n        next = (this.parse(current) as bigint) + BigInt(toIncrementBy);\n        break;\n      default:\n        throw new InternalError(\"Should never happen\");\n    }\n    let seq: Seq;\n    const repo = this.repo.override({\n      ignoredValidationProperties: [\"updatedOn\"],\n    });\n    try {\n      seq = await repo.update(new Seq({ id: name, current: next }));\n    } catch (e: any) {\n      if (!(e instanceof NotFoundError)) {\n        throw e;\n      }\n      seq = await repo.create(new Seq({ id: name, current: next }));\n    }\n\n    return seq.current as string | number | bigint;\n  }\n\n  /**\n   * @description Gets the next value in the sequence\n   * @summary Retrieves the current value of the sequence and increments it by the\n   * configured increment amount. This is the main method used to get a new sequential value.\n   * @return A promise that resolves to the next value in the sequence\n   */\n  async next(): Promise<number | string | bigint> {\n    const current = await this.current();\n    return this.increment(current);\n  }\n\n  /**\n   * @description Generates a range of sequential values\n   * @summary Retrieves a specified number of sequential values from the sequence.\n   * This is useful when you need to allocate multiple IDs at once.\n   * The method increments the sequence by the total amount needed and returns all values in the range.\n   * @param {number} count - The number of sequential values to generate\n   * @return A promise that resolves to an array of sequential values\n   */\n  async range(count: number): Promise<(number | string | bigint)[]> {\n    const current = (await this.current()) as number;\n    const incrementBy = this.parse(this.options.incrementBy) as number;\n    const next: string | number | bigint = await this.increment(\n      current,\n      (this.parse(count) as number) * incrementBy\n    );\n    const range: (number | string | bigint)[] = [];\n    for (let i: number = 1; i <= count; i++) {\n      range.push(current + incrementBy * (this.parse(i) as number));\n    }\n    if (range[range.length - 1] !== next)\n      throw new InternalError(\"Miscalculation of range\");\n    return range;\n  }\n}\n\n"]}

package/lib/ram/RamSequence.d.ts

@@ -3,12 +3,73 @@ import { Sequence } from "../persistence";
 import { SequenceOptions } from "../interfaces";
 import { RamAdapter } from "./RamAdapter";
 import { Repo } from "../repository";
+/**
+ * @description RAM-specific sequence implementation
+ * @summary Extends the base Sequence class to provide auto-incrementing sequence functionality
+ * for the RAM adapter. This class manages sequences stored in memory, allowing for the generation
+ * of sequential identifiers for entities.
+ * @param {SequenceOptions} options - Configuration options for the sequence
+ * @param {RamAdapter} adapter - The RAM adapter instance to use for storage
+ * @class RamSequence
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new numeric sequence starting at 1
+ * const sequence = new RamSequence({
+ *   name: 'order_sequence',
+ *   type: 'Number',
+ *   startWith: 1,
+ *   incrementBy: 1
+ * }, ramAdapter);
+ *
+ * // Get the next value in the sequence
+ * const nextId = await sequence.next();
+ *
+ * // Get a range of values
+ * const idRange = await sequence.range(5); // Returns 5 sequential values
+ * ```
+ */
 export declare class RamSequence extends Sequence {
     protected repo: Repo<Seq>;
     constructor(options: SequenceOptions, adapter: RamAdapter);
+    /**
+     * @description Retrieves the current value of the sequence
+     * @summary Gets the current value of the sequence from storage. If the sequence
+     * doesn't exist yet, it returns the configured starting value.
+     * @return A promise that resolves to the current sequence value
+     */
     current(): Promise<string | number | bigint>;
+    /**
+     * @description Parses a value according to the sequence type
+     * @summary Converts a value to the appropriate type for the sequence (string, number, or bigint)
+     * using the base Sequence class's parseValue method.
+     * @param {string | number | bigint} value - The value to parse
+     * @return {string | number | bigint} The parsed value in the correct type
+     */
     private parse;
+    /**
+     * @description Increments the sequence value
+     * @summary Increases the current sequence value by the specified amount and persists
+     * the new value to storage. This method handles both numeric and BigInt sequence types.
+     * @param {string | number | bigint} current - The current value of the sequence
+     * @param {number} [count] - Optional amount to increment by, defaults to the sequence's incrementBy value
+     * @return A promise that resolves to the new sequence value after incrementing
+     */
     private increment;
+    /**
+     * @description Gets the next value in the sequence
+     * @summary Retrieves the current value of the sequence and increments it by the
+     * configured increment amount. This is the main method used to get a new sequential value.
+     * @return A promise that resolves to the next value in the sequence
+     */
     next(): Promise<number | string | bigint>;
+    /**
+     * @description Generates a range of sequential values
+     * @summary Retrieves a specified number of sequential values from the sequence.
+     * This is useful when you need to allocate multiple IDs at once.
+     * The method increments the sequence by the total amount needed and returns all values in the range.
+     * @param {number} count - The number of sequential values to generate
+     * @return A promise that resolves to an array of sequential values
+     */
     range(count: number): Promise<(number | string | bigint)[]>;
 }

package/lib/ram/RamStatement.cjs

@@ -6,10 +6,43 @@ const RamPaginator_1 = require("./RamPaginator.cjs");
 const db_decorators_1 = require("@decaf-ts/db-decorators");
 const Statement_1 = require("./../query/Statement.cjs");
 const reflection_1 = require("@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();
+ * ```
+ */
 class RamStatement extends Statement_1.Statement {
     constructor(adapter) {
         super(adapter);
     }
+    /**
+     * @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)
@@ -42,6 +75,13 @@ class RamStatement extends Statement_1.Statement {
             }
         };
     }
+    /**
+     * @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,
@@ -59,6 +99,13 @@ class RamStatement extends Statement_1.Statement {
             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();
@@ -68,6 +115,33 @@ class RamStatement extends Statement_1.Statement {
             throw new db_decorators_1.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) => {
@@ -114,4 +188,4 @@ class RamStatement extends Statement_1.Statement {
     }
 }
 exports.RamStatement = RamStatement;
-//# 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\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  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  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  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  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"]}
+//# 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/ram/RamStatement.d.ts

@@ -3,10 +3,84 @@ import { RawRamQuery } from "./types";
 import { Model } from "@decaf-ts/decorator-validation";
 import { Statement } from "../query/Statement";
 import { RamAdapter } from "./RamAdapter";
+/**
+ * @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 declare class RamStatement<M extends Model, R> extends Statement<RawRamQuery<M>, M, R> {
     constructor(adapter: RamAdapter);
+    /**
+     * @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
+     */
     private getSort;
+    /**
+     * @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
+     */
     protected build(): RawRamQuery<M>;
+    /**
+     * @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
+     */
     paginate(size: number): Promise<Paginator<M, R, RawRamQuery<M>>>;
+    /**
+     * @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<M extends Model>(condition: Condition<M>): RawRamQuery<M>;
 }

package/lib/ram/constants.cjs

@@ -1,5 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RamFlavour = void 0;
+/**
+ * @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
+ */
 exports.RamFlavour = "ram";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JhbS9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQWEsUUFBQSxVQUFVLEdBQUcsS0FBSyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFJhbUZsYXZvdXIgPSBcInJhbVwiO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JhbS9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7Ozs7Ozs7R0FPRztBQUNVLFFBQUEsVUFBVSxHQUFHLEtBQUssQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGRlc2NyaXB0aW9uIElkZW50aWZpZXIgZm9yIHRoZSBSQU0gYWRhcHRlclxuICogQHN1bW1hcnkgQSBjb25zdGFudCBzdHJpbmcgdGhhdCB1bmlxdWVseSBpZGVudGlmaWVzIHRoZSBSQU0gYWRhcHRlciBpbiB0aGUgc3lzdGVtLlxuICogVXNlZCBmb3IgYWRhcHRlciB0eXBlIGlkZW50aWZpY2F0aW9uIGFuZCBjb25maWd1cmF0aW9uLlxuICogQGNvbnN0IFJhbUZsYXZvdXJcbiAqIEBtZW1iZXJPZiBtb2R1bGU6Y29yZVxuICogQGNhdGVnb3J5IFJhbVxuICovXG5leHBvcnQgY29uc3QgUmFtRmxhdm91ciA9IFwicmFtXCI7XG4iXX0=

package/lib/ram/constants.d.ts

@@ -1 +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/ram/handlers.cjs

@@ -2,10 +2,29 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createdByOnRamCreateUpdate = createdByOnRamCreateUpdate;
 const persistence_1 = require("./../persistence/index.cjs");
+/**
+ * @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
+ */
 async function createdByOnRamCreateUpdate(context, data, key, model) {
     const uuid = context.get("UUID");
     if (!uuid)
         throw new persistence_1.UnsupportedError("This adapter does not support user identification");
     model[key] = uuid;
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaGFuZGxlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmFtL2hhbmRsZXJzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBT0EsZ0VBbUJDO0FBckJELDREQUFrRDtBQUUzQyxLQUFLLFVBQVUsMEJBQTBCLENBUTlDLE9BQW1CLEVBQ25CLElBQU8sRUFDUCxHQUFZLEVBQ1osS0FBUTtJQUVSLE1BQU0sSUFBSSxHQUFXLE9BQU8sQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUM7SUFDekMsSUFBSSxDQUFDLElBQUk7UUFDUCxNQUFNLElBQUksOEJBQWdCLENBQ3hCLG1EQUFtRCxDQUNwRCxDQUFDO0lBQ0osS0FBSyxDQUFDLEdBQUcsQ0FBQyxHQUFHLElBQWtCLENBQUM7QUFDbEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1vZGVsIH0gZnJvbSBcIkBkZWNhZi10cy9kZWNvcmF0b3ItdmFsaWRhdGlvblwiO1xuaW1wb3J0IHsgUmVwbyB9IGZyb20gXCIuLi9yZXBvc2l0b3J5XCI7XG5pbXBvcnQgeyBSZWxhdGlvbnNNZXRhZGF0YSB9IGZyb20gXCIuLi9tb2RlbFwiO1xuaW1wb3J0IHsgUmFtRmxhZ3MgfSBmcm9tIFwiLi90eXBlc1wiO1xuaW1wb3J0IHsgQ29udGV4dCB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuaW1wb3J0IHsgVW5zdXBwb3J0ZWRFcnJvciB9IGZyb20gXCIuLi9wZXJzaXN0ZW5jZVwiO1xuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gY3JlYXRlZEJ5T25SYW1DcmVhdGVVcGRhdGU8XG4gIE0gZXh0ZW5kcyBNb2RlbCxcbiAgUiBleHRlbmRzIFJlcG88TSwgRiwgQz4sXG4gIFYgZXh0ZW5kcyBSZWxhdGlvbnNNZXRhZGF0YSxcbiAgRiBleHRlbmRzIFJhbUZsYWdzLFxuICBDIGV4dGVuZHMgQ29udGV4dDxGPixcbj4oXG4gIHRoaXM6IFIsXG4gIGNvbnRleHQ6IENvbnRleHQ8Rj4sXG4gIGRhdGE6IFYsXG4gIGtleToga2V5b2YgTSxcbiAgbW9kZWw6IE1cbik6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCB1dWlkOiBzdHJpbmcgPSBjb250ZXh0LmdldChcIlVVSURcIik7XG4gIGlmICghdXVpZClcbiAgICB0aHJvdyBuZXcgVW5zdXBwb3J0ZWRFcnJvcihcbiAgICAgIFwiVGhpcyBhZGFwdGVyIGRvZXMgbm90IHN1cHBvcnQgdXNlciBpZGVudGlmaWNhdGlvblwiXG4gICAgKTtcbiAgbW9kZWxba2V5XSA9IHV1aWQgYXMgTVtrZXlvZiBNXTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ram/handlers.d.ts

@@ -3,4 +3,23 @@ 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/ram/model/RamSequence.cjs

@@ -13,6 +13,24 @@ exports.Sequence = void 0;
 const decorator_validation_1 = require("@decaf-ts/decorator-validation");
 const model_1 = require("./../../model/index.cjs");
 const identity_1 = require("./../../identity/index.cjs");
+/**
+ * @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 model_1.BaseModel {
     constructor(seq) {
         super(seq);
@@ -33,4 +51,4 @@ exports.Sequence = Sequence = __decorate([
     (0, decorator_validation_1.model)(),
     __metadata("design:paramtypes", [Object])
 ], Sequence);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtU2VxdWVuY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcmFtL21vZGVsL1JhbVNlcXVlbmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7OztBQUFBLHlFQUFpRTtBQUVqRSxtREFBc0Q7QUFDdEQseURBQW9DO0FBSTdCLElBQU0sUUFBUSxHQUFkLE1BQU0sUUFBUyxTQUFRLGlCQUFTO0lBUXJDLFlBQVksR0FBd0I7UUFDbEMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsQ0FBQztDQUNGLENBQUE7QUFYWSw0QkFBUTtBQUVuQjtJQURDLElBQUEsYUFBRSxHQUFFOztvQ0FDTztBQUlaO0lBRkMsSUFBQSwrQkFBUSxHQUFFO0lBQ1YsSUFBQSxhQUFLLEdBQUU7O3lDQUNrQjttQkFOZixRQUFRO0lBRnBCLElBQUEsYUFBSyxFQUFDLGVBQWUsQ0FBQztJQUN0QixJQUFBLDRCQUFLLEdBQUU7O0dBQ0ssUUFBUSxDQVdwQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IG1vZGVsLCByZXF1aXJlZCB9IGZyb20gXCJAZGVjYWYtdHMvZGVjb3JhdG9yLXZhbGlkYXRpb25cIjtcbmltcG9ydCB0eXBlIHsgTW9kZWxBcmcgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyBCYXNlTW9kZWwsIGluZGV4LCB0YWJsZSB9IGZyb20gXCIuLi8uLi9tb2RlbFwiO1xuaW1wb3J0IHsgcGsgfSBmcm9tIFwiLi4vLi4vaWRlbnRpdHlcIjtcblxuQHRhYmxlKFwiX19SYW1TZXF1ZW5jZVwiKVxuQG1vZGVsKClcbmV4cG9ydCBjbGFzcyBTZXF1ZW5jZSBleHRlbmRzIEJhc2VNb2RlbCB7XG4gIEBwaygpXG4gIGlkITogc3RyaW5nO1xuXG4gIEByZXF1aXJlZCgpXG4gIEBpbmRleCgpXG4gIGN1cnJlbnQhOiBzdHJpbmcgfCBudW1iZXI7XG5cbiAgY29uc3RydWN0b3Ioc2VxPzogTW9kZWxBcmc8U2VxdWVuY2U+KSB7XG4gICAgc3VwZXIoc2VxKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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