@decaf-ts/core 0.4.1 → 0.5.0

package/lib/esm/ram/RamAdapter.js

@@ -0,0 +1,230 @@
+import { RamStatement } from "./RamStatement";
+import { RamClauseFactory } from "./RamClauseFactory";
+import * as crypto from "node:crypto";
+import { RamContext } from "./RamContext";
+import { Repository } from "../repository/Repository";
+import { UnsupportedError } from "../persistence/errors";
+import { Adapter, PersistenceKeys } from "../persistence";
+import { Paginator } from "../query/Paginator";
+import { GroupOperator, Operator, QueryError, } from "../query";
+import { Lock } from "@decaf-ts/transactional-decorators";
+import { Decoration, Model, propMetadata, } from "@decaf-ts/decorator-validation";
+import { BaseError, ConflictError, DefaultRepositoryFlags, findPrimaryKey, InternalError, NotFoundError, onCreate, OperationKeys, } from "@decaf-ts/db-decorators";
+import { RamSequence } from "./RamSequence";
+export async function createdByOnRamCreateUpdate(context, data, key, model) {
+    const uuid = context.get("UUID");
+    if (!uuid)
+        throw new UnsupportedError("This adapter does not support user identification");
+    model[key] = uuid;
+}
+const createdByKey = Repository.key(PersistenceKeys.CREATED_BY);
+const updatedByKey = Repository.key(PersistenceKeys.UPDATED_BY);
+Decoration.flavouredAs("ram")
+    .for(createdByKey)
+    .define(onCreate(createdByOnRamCreateUpdate), propMetadata(createdByKey, {}))
+    .apply();
+Decoration.flavouredAs("ram")
+    .for(updatedByKey)
+    .define(onCreate(createdByOnRamCreateUpdate), propMetadata(updatedByKey, {}))
+    .apply();
+export class RamAdapter extends Adapter {
+    constructor(flavour = "ram") {
+        super({}, flavour);
+        this.indexes = {};
+        this.lock = new Lock();
+        this.sequences = {};
+    }
+    async context(operation, overrides, model, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    ...args) {
+        return new RamContext(Object.assign({}, DefaultRepositoryFlags, overrides, {
+            affectedTables: [model.name],
+            writeOperation: operation !== OperationKeys.READ,
+            timestamp: new Date(),
+            operation: operation,
+            UUID: crypto.randomUUID(),
+        }));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async initialize(...args) {
+        return Promise.resolve(undefined);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async index(...models) {
+        return Promise.resolve(undefined);
+    }
+    prepare(model, pk) {
+        const prepared = super.prepare(model, pk);
+        delete prepared.record[pk];
+        return prepared;
+    }
+    revert(obj, clazz, pk, id) {
+        const res = super.revert(obj, clazz, pk, id);
+        return res;
+    }
+    async create(tableName, id, model) {
+        await this.lock.acquire();
+        if (!this.native[tableName])
+            this.native[tableName] = {};
+        if (id in this.native[tableName])
+            throw new ConflictError(`Record with id ${id} already exists in table ${tableName}`);
+        this.native[tableName][id] = model;
+        this.lock.release();
+        return model;
+    }
+    async read(tableName, id) {
+        if (!(tableName in this.native))
+            throw new NotFoundError(`Table ${tableName} not found`);
+        if (!(id in this.native[tableName]))
+            throw new NotFoundError(`Record with id ${id} not found in table ${tableName}`);
+        return this.native[tableName][id];
+    }
+    async update(tableName, id, model) {
+        await this.lock.acquire();
+        if (!(tableName in this.native))
+            throw new NotFoundError(`Table ${tableName} not found`);
+        if (!(id in this.native[tableName]))
+            throw new NotFoundError(`Record with id ${id} not found in table ${tableName}`);
+        this.native[tableName][id] = model;
+        this.lock.release();
+        return model;
+    }
+    async delete(tableName, id) {
+        await this.lock.acquire();
+        if (!(tableName in this.native))
+            throw new NotFoundError(`Table ${tableName} not found`);
+        if (!(id in this.native[tableName]))
+            throw new NotFoundError(`Record with id ${id} not found in table ${tableName}`);
+        const natived = this.native[tableName][id];
+        delete this.native[tableName][id];
+        this.lock.release();
+        return natived;
+    }
+    tableFor(from) {
+        if (typeof from === "string")
+            from = Model.get(from);
+        const table = Repository.table(from);
+        if (!(table in this.native))
+            this.native[table] = {};
+        return this.native[table];
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async raw(rawInput, process) {
+        const { where, sort, limit, skip, from } = rawInput;
+        let { select } = rawInput;
+        const collection = this.tableFor(from);
+        const clazz = typeof from === "string" ? Model.get(from) : from;
+        const { id, props } = findPrimaryKey(new clazz());
+        function parseId(id) {
+            let result = id;
+            switch (props.type) {
+                case "Number":
+                    result = parseInt(result);
+                    if (isNaN(result))
+                        throw new Error(`Invalid id ${id}`);
+                    break;
+                case "BigInt":
+                    result = BigInt(parseInt(result));
+                    break;
+                case "String":
+                    break;
+                default:
+                    throw new InternalError(`Invalid id type ${props.type}. should be impossible`);
+            }
+            return result;
+        }
+        let result = Object.entries(collection).map(([pk, r]) => this.revert(r, clazz, id, parseId(pk)));
+        result = where ? result.filter(where) : result;
+        if (sort)
+            result = result.sort(sort);
+        if (skip)
+            result = result.slice(skip);
+        if (limit)
+            result = result.slice(0, limit);
+        if (select) {
+            select = Array.isArray(select) ? select : [select];
+            result = result.map((r) => Object.entries(r).reduce((acc, [key, val]) => {
+                if (select.includes(key))
+                    acc[key] = val;
+                return acc;
+            }, {}));
+        }
+        return result;
+    }
+    async paginate(rawInput) {
+        return new (class extends Paginator {
+            constructor(size) {
+                super(undefined, size, rawInput);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            prepare(rawStatement) {
+                throw new Error("Method not implemented.");
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            page(page) {
+                throw new Error("Method not implemented.");
+            }
+        })(10);
+    }
+    parseError(err) {
+        if (err instanceof BaseError)
+            return err;
+        return new InternalError(err);
+    }
+    get Clauses() {
+        if (!this.factory)
+            this.factory = new RamClauseFactory(this);
+        return this.factory;
+    }
+    get Statement() {
+        return new RamStatement(this);
+    }
+    async Sequence(options) {
+        return new RamSequence(options, this);
+    }
+    parseCondition(condition) {
+        return {
+            where: (m) => {
+                const { attr1, operator, comparison } = condition;
+                if ([GroupOperator.AND, GroupOperator.OR, Operator.NOT].indexOf(operator) === -1) {
+                    switch (operator) {
+                        case Operator.BIGGER:
+                            return m[attr1] > comparison;
+                        case Operator.BIGGER_EQ:
+                            return m[attr1] >= comparison;
+                        case Operator.DIFFERENT:
+                            return m[attr1] !== comparison;
+                        case Operator.EQUAL:
+                            return m[attr1] === comparison;
+                        case Operator.REGEXP:
+                            if (typeof m[attr1] !== "string")
+                                throw new QueryError(`Invalid regexp comparison on a non string attribute: ${m[attr1]}`);
+                            return !!m[attr1].match(new RegExp(comparison, "g"));
+                        case Operator.SMALLER:
+                            return m[attr1] < comparison;
+                        case Operator.SMALLER_EQ:
+                            return m[attr1] <= comparison;
+                        default:
+                            throw new InternalError(`Invalid operator for standard comparisons: ${operator}`);
+                    }
+                }
+                else if (operator === Operator.NOT) {
+                    throw new InternalError("Not implemented");
+                }
+                else {
+                    const op1 = this.parseCondition(attr1);
+                    const op2 = this.parseCondition(comparison);
+                    switch (operator) {
+                        case GroupOperator.AND:
+                            return op1.where(m) && op2.where(m);
+                        case GroupOperator.OR:
+                            return op1.where(m) || op2.where(m);
+                        default:
+                            throw new InternalError(`Invalid operator for And/Or comparisons: ${operator}`);
+                    }
+                }
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamAdapter.js","sourceRoot":"","sources":["../../../src/ram/RamAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Context } from \"@decaf-ts/db-decorators\";\nimport { RamFlags, RamQuery, RamStorage } from \"./types\";\nimport { RamStatement } from \"./RamStatement\";\nimport { RamClauseFactory } from \"./RamClauseFactory\";\nimport * as crypto from \"node:crypto\";\nimport { RamContext } from \"./RamContext\";\nimport { Repo, Repository } from \"../repository/Repository\";\nimport { RelationsMetadata } from \"../model/types\";\nimport { UnsupportedError } from \"../persistence/errors\";\nimport { Adapter, PersistenceKeys, Sequence } from \"../persistence\";\nimport { Paginator } from \"../query/Paginator\";\nimport {\n  ClauseFactory,\n  Condition,\n  GroupOperator,\n  Operator,\n  QueryError,\n} from \"../query\";\nimport { SequenceOptions } from \"../interfaces\";\nimport { Lock } from \"@decaf-ts/transactional-decorators\";\nimport {\n  Constructor,\n  Decoration,\n  Model,\n  propMetadata,\n} from \"@decaf-ts/decorator-validation\";\nimport {\n  BaseError,\n  ConflictError,\n  DefaultRepositoryFlags,\n  findPrimaryKey,\n  InternalError,\n  NotFoundError,\n  onCreate,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { RamSequence } from \"./RamSequence\";\n\nexport async function createdByOnRamCreateUpdate<\n  M extends Model,\n  R extends Repo<M, C, F>,\n  V extends RelationsMetadata,\n  F extends RamFlags,\n  C extends Context<F>,\n>(\n  this: R,\n  context: Context<F>,\n  data: V,\n  key: keyof M,\n  model: M\n): Promise<void> {\n  const uuid: string = context.get(\"UUID\");\n  if (!uuid)\n    throw new UnsupportedError(\n      \"This adapter does not support user identification\"\n    );\n  model[key] = uuid as M[keyof M];\n}\n\nconst createdByKey = Repository.key(PersistenceKeys.CREATED_BY);\nconst updatedByKey = Repository.key(PersistenceKeys.UPDATED_BY);\nDecoration.flavouredAs(\"ram\")\n  .for(createdByKey)\n  .define(onCreate(createdByOnRamCreateUpdate), propMetadata(createdByKey, {}))\n  .apply();\nDecoration.flavouredAs(\"ram\")\n  .for(updatedByKey)\n  .define(onCreate(createdByOnRamCreateUpdate), propMetadata(updatedByKey, {}))\n  .apply();\n\nexport class RamAdapter extends Adapter<\n  RamStorage,\n  RamQuery<any>,\n  RamFlags,\n  Context<RamFlags>\n> {\n  protected factory?: RamClauseFactory;\n\n  constructor(flavour: string = \"ram\") {\n    super({}, flavour);\n  }\n\n  async context<M extends Model, C extends RamContext, F extends RamFlags>(\n    operation: any,\n    overrides: Partial<RamFlags>,\n    model: Constructor<M>,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    ...args: any[]\n  ): Promise<C> {\n    return new RamContext(\n      Object.assign({}, DefaultRepositoryFlags, overrides, {\n        affectedTables: [model.name],\n        writeOperation: operation !== OperationKeys.READ,\n        timestamp: new Date(),\n        operation: operation,\n        UUID: crypto.randomUUID(),\n      }) as F\n    ) as C;\n  }\n  private indexes: Record<\n    string,\n    Record<string | number, Record<string, any>>\n  > = {};\n\n  private lock = new Lock();\n\n  private sequences: Record<string, string | number> = {};\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async initialize(...args: any[]): Promise<void> {\n    return Promise.resolve(undefined);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async index(...models: Record<string, any>[]): Promise<any> {\n    return Promise.resolve(undefined);\n  }\n\n  prepare<M extends Model>(\n    model: M,\n    pk: keyof M\n  ): { record: Record<string, any>; id: string } {\n    const prepared = super.prepare(model, pk);\n    delete prepared.record[pk as string];\n    return prepared;\n  }\n\n  revert<M extends Model>(\n    obj: Record<string, any>,\n    clazz: string | Constructor<M>,\n    pk: keyof M,\n    id: string | number\n  ): M {\n    const res = super.revert(obj, clazz, pk, id);\n    return res;\n  }\n\n  async create(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>> {\n    await this.lock.acquire();\n    if (!this.native[tableName]) this.native[tableName] = {};\n    if (id in this.native[tableName])\n      throw new ConflictError(\n        `Record with id ${id} already exists in table ${tableName}`\n      );\n    this.native[tableName][id] = model;\n    this.lock.release();\n    return model;\n  }\n\n  async read(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>> {\n    if (!(tableName in this.native))\n      throw new NotFoundError(`Table ${tableName} not found`);\n    if (!(id in this.native[tableName]))\n      throw new NotFoundError(\n        `Record with id ${id} not found in table ${tableName}`\n      );\n    return this.native[tableName][id];\n  }\n\n  async update(\n    tableName: string,\n    id: string | number,\n    model: Record<string, any>\n  ): Promise<Record<string, any>> {\n    await this.lock.acquire();\n    if (!(tableName in this.native))\n      throw new NotFoundError(`Table ${tableName} not found`);\n    if (!(id in this.native[tableName]))\n      throw new NotFoundError(\n        `Record with id ${id} not found in table ${tableName}`\n      );\n    this.native[tableName][id] = model;\n    this.lock.release();\n    return model;\n  }\n\n  async delete(\n    tableName: string,\n    id: string | number\n  ): Promise<Record<string, any>> {\n    await this.lock.acquire();\n    if (!(tableName in this.native))\n      throw new NotFoundError(`Table ${tableName} not found`);\n    if (!(id in this.native[tableName]))\n      throw new NotFoundError(\n        `Record with id ${id} not found in table ${tableName}`\n      );\n    const natived = this.native[tableName][id];\n    delete this.native[tableName][id];\n    this.lock.release();\n    return natived;\n  }\n\n  protected tableFor<M extends Model>(from: string | Constructor<M>) {\n    if (typeof from === \"string\") from = Model.get(from) as Constructor<M>;\n    const table = Repository.table(from);\n    if (!(table in this.native)) this.native[table] = {};\n    return this.native[table];\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async raw<Z>(rawInput: RamQuery<any>, process: boolean): Promise<Z> {\n    const { where, sort, limit, skip, from } = rawInput;\n    let { select } = rawInput;\n    const collection = this.tableFor(from);\n\n    const clazz = typeof from === \"string\" ? Model.get(from) : from;\n    const { id, props } = findPrimaryKey(new clazz());\n\n    function parseId(id: any) {\n      let result = id;\n      switch (props.type) {\n        case \"Number\":\n          result = parseInt(result);\n          if (isNaN(result)) throw new Error(`Invalid id ${id}`);\n          break;\n        case \"BigInt\":\n          result = BigInt(parseInt(result));\n          break;\n        case \"String\":\n          break;\n        default:\n          throw new InternalError(\n            `Invalid id type ${props.type}. should be impossible`\n          );\n      }\n      return result;\n    }\n\n    let result: any[] = Object.entries(collection).map(([pk, r]) =>\n      this.revert(r, clazz, id as any, parseId(pk))\n    );\n\n    result = where ? result.filter(where) : result;\n\n    if (sort) result = result.sort(sort);\n\n    if (skip) result = result.slice(skip);\n    if (limit) result = result.slice(0, limit);\n\n    if (select) {\n      select = Array.isArray(select) ? select : [select];\n      result = result.map((r) =>\n        Object.entries(r).reduce((acc: Record<string, any>, [key, val]) => {\n          if ((select as string[]).includes(key)) acc[key] = val;\n          return acc;\n        }, {})\n      );\n    }\n\n    return result as unknown as Z;\n  }\n\n  async paginate<Z>(rawInput: string): Promise<Paginator<Z, string>> {\n    return new (class extends Paginator<Z, string> {\n      constructor(size: number) {\n        super(undefined as unknown as any, size, rawInput);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      protected prepare(rawStatement: string): string {\n        throw new Error(\"Method not implemented.\");\n      }\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      page(page: number): Promise<Z[]> {\n        throw new Error(\"Method not implemented.\");\n      }\n    })(10);\n  }\n\n  parseError<V extends BaseError>(err: Error): V {\n    if (err instanceof BaseError) return err as V;\n    return new InternalError(err) as V;\n  }\n\n  get Clauses(): ClauseFactory<RamStorage, RamQuery<any>, typeof this> {\n    if (!this.factory) this.factory = new RamClauseFactory(this);\n    return this.factory as any;\n  }\n\n  get Statement(): RamStatement<any> {\n    return new RamStatement(this);\n  }\n\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new RamSequence(options, this);\n  }\n\n  parseCondition(condition: Condition): RamQuery<any> {\n    return {\n      where: (m: Model) => {\n        const { attr1, operator, comparison } = condition as unknown as {\n          attr1: string | Condition;\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: RamQuery<any> = this.parseCondition(attr1 as Condition);\n          const op2: RamQuery<any> = this.parseCondition(\n            comparison as Condition\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 RamQuery<any>;\n  }\n}\n"]}

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

@@ -0,0 +1,17 @@
+import { ClauseFactory, Condition, FromClause, FromSelector, GroupByClause, GroupBySelector, InsertClause, LimitClause, LimitSelector, OffsetClause, OffsetSelector, OrderByClause, OrderBySelector, SelectClause, SelectSelector, ValuesClause, WhereClause } from "../query";
+import { RamQuery, RamStorage } from "./types";
+import { RamAdapter } from "./RamAdapter";
+import { RamStatement } from "./RamStatement";
+import { Model } from "@decaf-ts/decorator-validation";
+export declare class RamClauseFactory extends ClauseFactory<RamStorage, RamQuery<any>, RamAdapter> {
+    constructor(adapter: RamAdapter);
+    from<M extends Model>(statement: RamStatement<M>, selector: FromSelector<M>): FromClause<RamQuery<any>, M>;
+    groupBy(statement: RamStatement<any>, selector: GroupBySelector): GroupByClause<RamQuery<any>>;
+    insert<M extends Model>(): InsertClause<RamQuery<any>, M>;
+    limit(statement: RamStatement<any>, selector: LimitSelector): LimitClause<RamQuery<any>>;
+    offset(statement: RamStatement<any>, selector: OffsetSelector): OffsetClause<RamQuery<any>>;
+    orderBy(statement: RamStatement<any>, selector: OrderBySelector[]): OrderByClause<RamQuery<any>>;
+    select<M extends Model>(selector: SelectSelector | undefined): SelectClause<RamQuery<any>, M>;
+    values<M extends Model>(statement: RamStatement<any>, values: M[]): ValuesClause<RamQuery<any>, M>;
+    where(statement: RamStatement<any>, condition: Condition): WhereClause<RamQuery<any>>;
+}

package/lib/esm/ram/RamClauseFactory.js

@@ -0,0 +1,92 @@
+import { ClauseFactory, GroupByClause, LimitClause, OffsetClause, QueryError, } from "../query";
+import { RamStatement } from "./RamStatement";
+import { InternalError } from "@decaf-ts/db-decorators";
+import { RamInsertClause } from "./clauses/InsertClause";
+import { RamOrderByClause } from "./clauses/OrderByClause";
+import { RamSelectClause } from "./clauses/SelectClause";
+import { RamValuesClause } from "./clauses/ValuesClause";
+import { RamWhereClause } from "./clauses/WhereClause";
+import { RamFromClause } from "./clauses/FromClause";
+export class RamClauseFactory extends ClauseFactory {
+    constructor(adapter) {
+        super(adapter);
+    }
+    from(statement, selector) {
+        return new RamFromClause({ statement: statement, selector: selector });
+    }
+    groupBy(statement, selector) {
+        return new (class extends GroupByClause {
+            constructor(clause) {
+                super(clause);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            build(query) {
+                throw new InternalError("Not implemented");
+            }
+        })({
+            statement: statement,
+            selector: selector,
+        });
+    }
+    insert() {
+        return new RamInsertClause({
+            statement: new RamStatement(this.adapter),
+        });
+    }
+    limit(statement, selector) {
+        return new (class extends LimitClause {
+            constructor(clause) {
+                super(clause);
+            }
+            build(query) {
+                query.limit = this.selector;
+                return query;
+            }
+        })({
+            statement: statement,
+            selector: selector,
+        });
+    }
+    offset(statement, selector) {
+        return new (class extends OffsetClause {
+            constructor(clause) {
+                super(clause);
+            }
+            build(query) {
+                const skip = parseInt(this.selector);
+                if (isNaN(skip))
+                    throw new QueryError("Failed to parse offset");
+                query.skip = skip;
+                return query;
+            }
+        })({
+            statement: statement,
+            selector: selector,
+        });
+    }
+    orderBy(statement, selector) {
+        return new RamOrderByClause({
+            statement: statement,
+            selector: selector,
+        });
+    }
+    select(selector) {
+        return new RamSelectClause({
+            statement: new RamStatement(this.adapter),
+            selector: selector,
+        });
+    }
+    values(statement, values) {
+        return new RamValuesClause({
+            statement: statement,
+            values: values,
+        });
+    }
+    where(statement, condition) {
+        return new RamWhereClause({
+            statement: statement,
+            condition: condition,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamClauseFactory.js","sourceRoot":"","sources":["../../../src/ram/RamClauseFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ClauseFactory,\n  Condition,\n  FromClause,\n  FromSelector,\n  GroupByClause,\n  GroupBySelector,\n  InsertClause,\n  LimitClause,\n  LimitSelector,\n  OffsetClause,\n  OffsetSelector,\n  OrderByClause,\n  OrderBySelector,\n  QueryError,\n  SelectClause,\n  SelectSelector,\n  ValuesClause,\n  WhereClause,\n} from \"../query\";\nimport { RamQuery, RamStorage } from \"./types\";\nimport { RamAdapter } from \"./RamAdapter\";\nimport { RamStatement } from \"./RamStatement\";\nimport { Model, ModelArg } from \"@decaf-ts/decorator-validation\";\nimport { InternalError } from \"@decaf-ts/db-decorators\";\nimport { RamInsertClause } from \"./clauses/InsertClause\";\nimport { RamOrderByClause } from \"./clauses/OrderByClause\";\nimport { RamSelectClause } from \"./clauses/SelectClause\";\nimport { RamValuesClause } from \"./clauses/ValuesClause\";\nimport { RamWhereClause } from \"./clauses/WhereClause\";\nimport { RamFromClause } from \"./clauses/FromClause\";\n\nexport class RamClauseFactory extends ClauseFactory<\n  RamStorage,\n  RamQuery<any>,\n  RamAdapter\n> {\n  constructor(adapter: RamAdapter) {\n    super(adapter);\n  }\n\n  from<M extends Model>(\n    statement: RamStatement<M>,\n    selector: FromSelector<M>\n  ): FromClause<RamQuery<any>, M> {\n    return new RamFromClause({ statement: statement, selector: selector });\n  }\n\n  groupBy(\n    statement: RamStatement<any>,\n    selector: GroupBySelector\n  ): GroupByClause<RamQuery<any>> {\n    return new (class extends GroupByClause<RamQuery<any>> {\n      constructor(clause: ModelArg<GroupByClause<RamQuery<any>>>) {\n        super(clause);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-unused-vars\n      build(query: RamQuery<any>): RamQuery<any> {\n        throw new InternalError(\"Not implemented\");\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  insert<M extends Model>(): InsertClause<RamQuery<any>, M> {\n    return new RamInsertClause({\n      statement: new RamStatement(this.adapter),\n    });\n  }\n\n  limit(\n    statement: RamStatement<any>,\n    selector: LimitSelector\n  ): LimitClause<RamQuery<any>> {\n    return new (class extends LimitClause<RamQuery<any>> {\n      constructor(clause: ModelArg<LimitClause<RamQuery<any>>>) {\n        super(clause);\n      }\n\n      build(query: RamQuery<any>): RamQuery<any> {\n        query.limit = this.selector as number;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  offset(\n    statement: RamStatement<any>,\n    selector: OffsetSelector\n  ): OffsetClause<RamQuery<any>> {\n    return new (class extends OffsetClause<RamQuery<any>> {\n      constructor(clause: ModelArg<OffsetClause<RamQuery<any>>>) {\n        super(clause);\n      }\n\n      build(query: RamQuery<any>): RamQuery<any> {\n        const skip: number = parseInt(this.selector as unknown as string);\n        if (isNaN(skip)) throw new QueryError(\"Failed to parse offset\");\n        query.skip = skip;\n        return query;\n      }\n    })({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  orderBy(\n    statement: RamStatement<any>,\n    selector: OrderBySelector[]\n  ): OrderByClause<RamQuery<any>> {\n    return new RamOrderByClause({\n      statement: statement,\n      selector: selector,\n    });\n  }\n\n  select<M extends Model>(\n    selector: SelectSelector | undefined\n  ): SelectClause<RamQuery<any>, M> {\n    return new RamSelectClause({\n      statement: new RamStatement(this.adapter),\n      selector: selector,\n    });\n  }\n\n  values<M extends Model>(\n    statement: RamStatement<any>,\n    values: M[]\n  ): ValuesClause<RamQuery<any>, M> {\n    return new RamValuesClause<M>({\n      statement: statement,\n      values: values,\n    });\n  }\n\n  where(\n    statement: RamStatement<any>,\n    condition: Condition\n  ): WhereClause<RamQuery<any>> {\n    return new RamWhereClause({\n      statement: statement,\n      condition: condition,\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,5 @@
+import { Context } from "@decaf-ts/db-decorators";
+import { RamFlags } from "./types";
+export declare class RamContext extends Context<RamFlags> {
+    constructor(obj: RamFlags);
+}

package/lib/esm/ram/RamContext.js

@@ -0,0 +1,7 @@
+import { Context } from "@decaf-ts/db-decorators";
+export class RamContext extends Context {
+    constructor(obj) {
+        super(obj);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9yYW0vUmFtQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0seUJBQXlCLENBQUM7QUFHbEQsTUFBTSxPQUFPLFVBQVcsU0FBUSxPQUFpQjtJQUMvQyxZQUFZLEdBQWE7UUFDdkIsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2IsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29udGV4dCB9IGZyb20gXCJAZGVjYWYtdHMvZGItZGVjb3JhdG9yc1wiO1xuaW1wb3J0IHsgUmFtRmxhZ3MgfSBmcm9tIFwiLi90eXBlc1wiO1xuXG5leHBvcnQgY2xhc3MgUmFtQ29udGV4dCBleHRlbmRzIENvbnRleHQ8UmFtRmxhZ3M+IHtcbiAgY29uc3RydWN0b3Iob2JqOiBSYW1GbGFncykge1xuICAgIHN1cGVyKG9iaik7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,7 @@
+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[]>;
+}

package/lib/esm/ram/RamPaginator.js

@@ -0,0 +1,20 @@
+import { Paginator } from "../query";
+export class RamPaginator extends Paginator {
+    constructor(statement, size, rawStatement) {
+        super(statement, size, rawStatement);
+    }
+    prepare(rawStatement) {
+        const query = Object.assign({}, rawStatement);
+        query.limit = this.size;
+        return query;
+    }
+    async page(page = 1, ...args) {
+        page = this.validatePage(page);
+        const statement = this.prepare(this.statement);
+        statement.skip = (page - 1) * this.size;
+        const results = await this.adapter.raw(statement, false, ...args);
+        this._currentPage = page;
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,50 @@
+import { Sequence as Seq } from "./model/RamSequence";
+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
+ *
+ * @param {SequenceOptions} options
+ *
+ * @class CouchDBSequence
+ * @implements Sequence
+ *
+ * @category Sequences
+ */
+export declare class RamSequence extends Sequence {
+    protected repo: Repo<Seq>;
+    constructor(options: SequenceOptions, adapter: RamAdapter);
+    /**
+     * @summary Retrieves the current value for the sequence
+     * @protected
+     */
+    current(): Promise<string | number | bigint>;
+    /**
+     * @summary Parses the {@link Sequence} value
+     *
+     * @protected
+     * @param value
+     */
+    private parse;
+    /**
+     * @summary increments the sequence
+     * @description Sequence specific implementation
+     *
+     * @param {string | number | bigint} current
+     * @param count
+     * @protected
+     */
+    private increment;
+    /**
+     * @summary Generates the next value in th sequence
+     * @description calls {@link Sequence#parse} on the current value
+     * followed by {@link Sequence#increment}
+     *
+     */
+    next(): Promise<number | string | bigint>;
+    range(count: number): Promise<(number | string | bigint)[]>;
+}