@decaf-ts/core
Version:
Core persistence module for the decaf framework
191 lines • 26.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.RamStatement = void 0;
const query_1 = require("./../query/index.cjs");
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)
throw new db_decorators_1.InternalError("orderBySelector not set. Should be impossible");
const selector = this.orderBySelector;
const [key, direction] = selector;
const type = reflection_1.Reflection.getTypeFromDecorator(el1, key);
if (!type)
throw new query_1.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 query_1.QueryError(`Sorting not supported for not date classes`);
default:
throw new query_1.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_1.RamPaginator(this.adapter, query, size, this.fromSelector);
}
catch (e) {
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) => {
const { attr1, operator, comparison } = condition;
if ([query_1.GroupOperator.AND, query_1.GroupOperator.OR, query_1.Operator.NOT].indexOf(operator) === -1) {
switch (operator) {
case query_1.Operator.BIGGER:
return m[attr1] > comparison;
case query_1.Operator.BIGGER_EQ:
return m[attr1] >= comparison;
case query_1.Operator.DIFFERENT:
return m[attr1] !== comparison;
case query_1.Operator.EQUAL:
return m[attr1] === comparison;
case query_1.Operator.REGEXP:
if (typeof m[attr1] !== "string")
throw new query_1.QueryError(`Invalid regexp comparison on a non string attribute: ${m[attr1]}`);
return !!m[attr1].match(new RegExp(comparison, "g"));
case query_1.Operator.SMALLER:
return m[attr1] < comparison;
case query_1.Operator.SMALLER_EQ:
return m[attr1] <= comparison;
default:
throw new db_decorators_1.InternalError(`Invalid operator for standard comparisons: ${operator}`);
}
}
else if (operator === query_1.Operator.NOT) {
throw new db_decorators_1.InternalError("Not implemented");
}
else {
const op1 = this.parseCondition(attr1);
const op2 = this.parseCondition(comparison);
switch (operator) {
case query_1.GroupOperator.AND:
return op1.where(m) && op2.where(m);
case query_1.GroupOperator.OR:
return op1.where(m) || op2.where(m);
default:
throw new db_decorators_1.InternalError(`Invalid operator for And/Or comparisons: ${operator}`);
}
}
},
};
}
}
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\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"]}