@decaf-ts/core 0.5.0 → 0.5.2

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

@@ -1,5 +1,20 @@
 import { Context } from "@decaf-ts/db-decorators";
 import { RamFlags } from "./types";
+/**
+ * @description Context class for RAM adapter operations
+ * @summary Provides a specialized context for RAM adapter operations, extending the base Context
+ * with RAM-specific flags. This context is used to pass operation parameters and user information.
+ * @class RamContext
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new RAM context with UUID
+ * const context = new RamContext({ UUID: '123e4567-e89b-12d3-a456-426614174000' });
+ *
+ * // Access the UUID from the context
+ * const uuid = context.get('UUID');
+ * ```
+ */
 export declare class RamContext extends Context<RamFlags> {
-    constructor(obj: RamFlags);
+    constructor();
 }

package/lib/esm/ram/RamContext.js

@@ -1,7 +1,22 @@
 import { Context } from "@decaf-ts/db-decorators";
+/**
+ * @description Context class for RAM adapter operations
+ * @summary Provides a specialized context for RAM adapter operations, extending the base Context
+ * with RAM-specific flags. This context is used to pass operation parameters and user information.
+ * @class RamContext
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new RAM context with UUID
+ * const context = new RamContext({ UUID: '123e4567-e89b-12d3-a456-426614174000' });
+ *
+ * // Access the UUID from the context
+ * const uuid = context.get('UUID');
+ * ```
+ */
 export class RamContext extends Context {
-    constructor(obj) {
-        super(obj);
+    constructor() {
+        super();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yYW0vUmFtQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHbEQsTUFBTSxPQUFPLFVBQVcsU0FBUSxPQUFpQjtJQUMvQyxZQUFZLEdBQWE7UUFDdkIsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGV4dCB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuaW1wb3J0IHsgUmFtRmxhZ3MgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG5leHBvcnQgY2xhc3MgUmFtQ29udGV4dCBleHRlbmRzIENvbnRleHQ8UmFtRmxhZ3M+IHtcbiAgY29uc3RydWN0b3Iob2JqOiBSYW1GbGFncykge1xuICAgIHN1cGVyKG9iaik7XG4gIH1cbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yYW0vUmFtQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHbEQ7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFDSCxNQUFNLE9BQU8sVUFBVyxTQUFRLE9BQWlCO0lBQy9DO1FBQ0UsS0FBSyxFQUFFLENBQUM7SUFDVixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb250ZXh0IH0gZnJvbSBcIkBkZWNhZi10cy9kYi1kZWNvcmF0b3JzXCI7XG5pbXBvcnQgeyBSYW1GbGFncyB9IGZyb20gXCIuL3R5cGVzXCI7XG5cbi8qKlxuICogQGRlc2NyaXB0aW9uIENvbnRleHQgY2xhc3MgZm9yIFJBTSBhZGFwdGVyIG9wZXJhdGlvbnNcbiAqIEBzdW1tYXJ5IFByb3ZpZGVzIGEgc3BlY2lhbGl6ZWQgY29udGV4dCBmb3IgUkFNIGFkYXB0ZXIgb3BlcmF0aW9ucywgZXh0ZW5kaW5nIHRoZSBiYXNlIENvbnRleHRcbiAqIHdpdGggUkFNLXNwZWNpZmljIGZsYWdzLiBUaGlzIGNvbnRleHQgaXMgdXNlZCB0byBwYXNzIG9wZXJhdGlvbiBwYXJhbWV0ZXJzIGFuZCB1c2VyIGluZm9ybWF0aW9uLlxuICogQGNsYXNzIFJhbUNvbnRleHRcbiAqIEBjYXRlZ29yeSBSYW1cbiAqIEBleGFtcGxlXG4gKiBgYGB0eXBlc2NyaXB0XG4gKiAvLyBDcmVhdGUgYSBuZXcgUkFNIGNvbnRleHQgd2l0aCBVVUlEXG4gKiBjb25zdCBjb250ZXh0ID0gbmV3IFJhbUNvbnRleHQoeyBVVUlEOiAnMTIzZTQ1NjctZTg5Yi0xMmQzLWE0NTYtNDI2NjE0MTc0MDAwJyB9KTtcbiAqXG4gKiAvLyBBY2Nlc3MgdGhlIFVVSUQgZnJvbSB0aGUgY29udGV4dFxuICogY29uc3QgdXVpZCA9IGNvbnRleHQuZ2V0KCdVVUlEJyk7XG4gKiBgYGBcbiAqL1xuZXhwb3J0IGNsYXNzIFJhbUNvbnRleHQgZXh0ZW5kcyBDb250ZXh0PFJhbUZsYWdzPiB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIHN1cGVyKCk7XG4gIH1cbn1cbiJdfQ==

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

@@ -1,7 +1,52 @@
-import { RamQuery } from "./types";
-import { Paginator, Statement } from "../query";
-export declare class RamPaginator<V> extends Paginator<V, RamQuery<any>> {
-    constructor(statement: Statement<RamQuery<any>>, size: number, rawStatement: RamQuery<any>);
-    protected prepare(rawStatement: RamQuery<any>): RamQuery<any>;
-    page(page?: number, ...args: any[]): Promise<V[]>;
+import { RawRamQuery } from "./types";
+import { Paginator } from "../query";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Adapter } from "../persistence";
+/**
+ * @description RAM-specific paginator implementation
+ * @summary Extends the base Paginator class to provide pagination functionality for RAM adapter queries.
+ * This class handles the pagination of query results from the in-memory storage, allowing
+ * for efficient retrieval of large result sets in smaller chunks.
+ * @template M - The model type being paginated
+ * @template R - The result type returned by the paginator
+ * @class RamPaginator
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a query for User model
+ * const query: RawRamQuery<User> = {
+ *   select: undefined, // Select all fields
+ *   from: User,
+ *   where: (user) => user.active === true
+ * };
+ *
+ * // Create a paginator with page size of 10
+ * const paginator = new RamPaginator<User, User>(adapter, query, 10, User);
+ *
+ * // Get the first page of results
+ * const firstPage = await paginator.page(1);
+ *
+ * // Get the next page
+ * const secondPage = await paginator.page(2);
+ * ```
+ */
+export declare class RamPaginator<M extends Model, R> extends Paginator<M, R, RawRamQuery<M>> {
+    constructor(adapter: Adapter<any, RawRamQuery<M>, any, any>, query: RawRamQuery<M>, size: number, clazz: Constructor<M>);
+    /**
+     * @description Prepares a RAM query for pagination
+     * @summary Modifies the raw query statement to include pagination parameters.
+     * This protected method sets the limit parameter on the query to match the page size.
+     * @param {RawRamQuery<M>} rawStatement - The original query statement
+     * @return {RawRamQuery<M>} The modified query with pagination parameters
+     */
+    protected prepare(rawStatement: RawRamQuery<M>): RawRamQuery<M>;
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination parameters to retrieve a specific page of results.
+     * This method calculates the appropriate skip value based on the page number and page size,
+     * executes the query, and updates the current page tracking.
+     * @param {number} [page=1] - The page number to retrieve (1-based)
+     * @return {Promise<R[]>} A promise that resolves to an array of results for the requested page
+     */
+    page(page?: number): Promise<R[]>;
 }

package/lib/esm/ram/RamPaginator.js

@@ -1,20 +1,72 @@
 import { Paginator } from "../query";
+/**
+ * @description RAM-specific paginator implementation
+ * @summary Extends the base Paginator class to provide pagination functionality for RAM adapter queries.
+ * This class handles the pagination of query results from the in-memory storage, allowing
+ * for efficient retrieval of large result sets in smaller chunks.
+ * @template M - The model type being paginated
+ * @template R - The result type returned by the paginator
+ * @class RamPaginator
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a query for User model
+ * const query: RawRamQuery<User> = {
+ *   select: undefined, // Select all fields
+ *   from: User,
+ *   where: (user) => user.active === true
+ * };
+ *
+ * // Create a paginator with page size of 10
+ * const paginator = new RamPaginator<User, User>(adapter, query, 10, User);
+ *
+ * // Get the first page of results
+ * const firstPage = await paginator.page(1);
+ *
+ * // Get the next page
+ * const secondPage = await paginator.page(2);
+ * ```
+ */
 export class RamPaginator extends Paginator {
-    constructor(statement, size, rawStatement) {
-        super(statement, size, rawStatement);
+    constructor(adapter, query, size, clazz) {
+        super(adapter, query, size, clazz);
     }
+    /**
+     * @description Prepares a RAM query for pagination
+     * @summary Modifies the raw query statement to include pagination parameters.
+     * This protected method sets the limit parameter on the query to match the page size.
+     * @param {RawRamQuery<M>} rawStatement - The original query statement
+     * @return {RawRamQuery<M>} The modified query with pagination parameters
+     */
     prepare(rawStatement) {
         const query = Object.assign({}, rawStatement);
         query.limit = this.size;
         return query;
     }
-    async page(page = 1, ...args) {
-        page = this.validatePage(page);
+    /**
+     * @description Retrieves a specific page of results
+     * @summary Executes the query with pagination parameters to retrieve a specific page of results.
+     * This method calculates the appropriate skip value based on the page number and page size,
+     * executes the query, and updates the current page tracking.
+     * @param {number} [page=1] - The page number to retrieve (1-based)
+     * @return {Promise<R[]>} A promise that resolves to an array of results for the requested page
+     */
+    async page(page = 1) {
         const statement = this.prepare(this.statement);
+        if (!this._recordCount || !this._totalPages) {
+            this._totalPages = this._recordCount = 0;
+            const results = await this.adapter.raw({ ...statement, limit: undefined }) || [];
+            this._recordCount = results.length;
+            if (this._recordCount > 0) {
+                const size = statement?.limit || this.size;
+                this._totalPages = Math.ceil(this._recordCount / size);
+            }
+        }
+        page = this.validatePage(page);
         statement.skip = (page - 1) * this.size;
-        const results = await this.adapter.raw(statement, false, ...args);
+        const results = await this.adapter.raw(statement);
         this._currentPage = page;
         return results;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -3,48 +3,73 @@ import { Sequence } from "../persistence";
 import { SequenceOptions } from "../interfaces";
 import { RamAdapter } from "./RamAdapter";
 import { Repo } from "../repository";
-export declare function parseSequenceValue(type: "Number" | "BigInt" | undefined, value: string | number | bigint): string | number | bigint;
 /**
- * @summary Abstract implementation of a Sequence
- * @description provides the basic functionality for {@link Sequence}s
+ * @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);
  *
- * @param {SequenceOptions} options
+ * // Get the next value in the sequence
+ * const nextId = await sequence.next();
  *
- * @class CouchDBSequence
- * @implements Sequence
- *
- * @category Sequences
+ * // 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);
     /**
-     * @summary Retrieves the current value for the sequence
-     * @protected
+     * @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>;
     /**
-     * @summary Parses the {@link Sequence} value
-     *
-     * @protected
-     * @param value
+     * @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;
     /**
-     * @summary increments the sequence
-     * @description Sequence specific implementation
-     *
-     * @param {string | number | bigint} current
-     * @param count
-     * @protected
+     * @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;
     /**
-     * @summary Generates the next value in th sequence
-     * @description calls {@link Sequence#parse} on the current value
-     * followed by {@link Sequence#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/esm/ram/RamSequence.js

@@ -2,39 +2,42 @@ import { Sequence as Seq } from "./model/RamSequence";
 import { InternalError, NotFoundError } from "@decaf-ts/db-decorators";
 import { Sequence } from "../persistence";
 import { Repository } from "../repository";
-export function parseSequenceValue(type, value) {
-    switch (type) {
-        case "Number":
-            return typeof value === "string"
-                ? parseInt(value)
-                : typeof value === "number"
-                    ? value
-                    : BigInt(value);
-        case "BigInt":
-            return BigInt(value);
-        default:
-            throw new InternalError("Should never happen");
-    }
-}
 /**
- * @summary Abstract implementation of a Sequence
- * @description provides the basic functionality for {@link Sequence}s
- *
- * @param {SequenceOptions} options
+ * @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);
  *
- * @class CouchDBSequence
- * @implements Sequence
+ * // Get the next value in the sequence
+ * const nextId = await sequence.next();
  *
- * @category Sequences
+ * // Get a range of values
+ * const idRange = await sequence.range(5); // Returns 5 sequential values
+ * ```
  */
 export class RamSequence extends Sequence {
     constructor(options, adapter) {
         super(options);
-        this.repo = Repository.forModel(Seq, adapter.flavour);
+        this.repo = Repository.forModel(Seq, adapter.alias);
     }
     /**
-     * @summary Retrieves the current value for the sequence
-     * @protected
+     * @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;
@@ -57,21 +60,22 @@ export class RamSequence extends Sequence {
         }
     }
     /**
-     * @summary Parses the {@link Sequence} value
-     *
-     * @protected
-     * @param value
+     * @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 parseSequenceValue(this.options.type, value);
+        return Sequence.parseValue(this.options.type, value);
     }
     /**
-     * @summary increments the sequence
-     * @description Sequence specific implementation
-     *
-     * @param {string | number | bigint} current
-     * @param count
-     * @protected
+     * @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;
@@ -105,15 +109,23 @@ export class RamSequence extends Sequence {
         return seq.current;
     }
     /**
-     * @summary Generates the next value in th sequence
-     * @description calls {@link Sequence#parse} on the current value
-     * followed by {@link Sequence#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
      */
     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);
@@ -127,4 +139,4 @@ export class RamSequence extends Sequence {
         return range;
     }
 }
-//# 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 function parseSequenceValue(\n  type: \"Number\" | \"BigInt\" | undefined,\n  value: string | number | bigint\n): string | number | bigint {\n  switch (type) {\n    case \"Number\":\n      return typeof value === \"string\"\n        ? parseInt(value)\n        : typeof value === \"number\"\n          ? value\n          : BigInt(value);\n    case \"BigInt\":\n      return BigInt(value);\n    default:\n      throw new InternalError(\"Should never happen\");\n  }\n}\n\n/**\n * @summary Abstract implementation of a Sequence\n * @description provides the basic functionality for {@link Sequence}s\n *\n * @param {SequenceOptions} options\n *\n * @class CouchDBSequence\n * @implements Sequence\n *\n * @category Sequences\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  /**\n   * @summary Retrieves the current value for the sequence\n   * @protected\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   * @summary Parses the {@link Sequence} value\n   *\n   * @protected\n   * @param value\n   */\n  private parse(value: string | number | bigint): string | number | bigint {\n    return parseSequenceValue(this.options.type, value);\n  }\n\n  /**\n   * @summary increments the sequence\n   * @description Sequence specific implementation\n   *\n   * @param {string | number | bigint} current\n   * @param count\n   * @protected\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   * @summary Generates the next value in th sequence\n   * @description calls {@link Sequence#parse} on the current value\n   * followed by {@link Sequence#increment}\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/esm/ram/RamStatement.d.ts

@@ -1,8 +1,86 @@
-import { Paginator, Statement } from "../query";
-import { RamQuery } from "./types";
+import { Condition, Paginator } from "../query";
+import { RawRamQuery } from "./types";
 import { Model } from "@decaf-ts/decorator-validation";
-import { Adapter } from "../persistence";
-export declare class RamStatement<M extends Model> extends Statement<RamQuery<M>> {
-    constructor(db: Adapter<any, RamQuery<M>, any, any>);
-    paginate<V>(size: number): Promise<Paginator<V, RamQuery<M>>>;
+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>;
 }