@decaf-ts/core 0.4.1 → 0.5.1

package/lib/ram/RamAdapter.cjs

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RamAdapter = void 0;
+const RamStatement_1 = require("./RamStatement.cjs");
+const RamContext_1 = require("./RamContext.cjs");
+const Repository_1 = require("./../repository/Repository.cjs");
+const persistence_1 = require("./../persistence/index.cjs");
+const transactional_decorators_1 = require("@decaf-ts/transactional-decorators");
+const decorator_validation_1 = require("@decaf-ts/decorator-validation");
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+const RamSequence_1 = require("./RamSequence.cjs");
+const handlers_1 = require("./handlers.cjs");
+const constants_1 = require("./constants.cjs");
+class RamAdapter extends persistence_1.Adapter {
+    constructor(alias) {
+        super(new Map(), constants_1.RamFlavour, alias);
+        this.Context = RamContext_1.RamContext;
+        this.indexes = {};
+        this.lock = new transactional_decorators_1.Lock();
+    }
+    repository() {
+        return super.repository();
+    }
+    flags(operation, model, flags) {
+        return Object.assign(super.flags(operation, model, flags), {
+            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.has(tableName))
+            this.native.set(tableName, new Map());
+        if (this.native.get(tableName) && this.native.get(tableName)?.has(id))
+            throw new db_decorators_1.ConflictError(`Record with id ${id} already exists in table ${tableName}`);
+        this.native.get(tableName)?.set(id, model);
+        this.lock.release();
+        return model;
+    }
+    async read(tableName, id) {
+        if (!this.native.has(tableName))
+            throw new db_decorators_1.NotFoundError(`Table ${tableName} not found`);
+        if (!this.native.get(tableName)?.has(id))
+            throw new db_decorators_1.NotFoundError(`Record with id ${id} not found in table ${tableName}`);
+        return this.native.get(tableName)?.get(id);
+    }
+    async update(tableName, id, model) {
+        await this.lock.acquire();
+        if (!this.native.has(tableName))
+            throw new db_decorators_1.NotFoundError(`Table ${tableName} not found`);
+        if (!this.native.get(tableName)?.has(id))
+            throw new db_decorators_1.NotFoundError(`Record with id ${id} not found in table ${tableName}`);
+        this.native.get(tableName)?.set(id, model);
+        this.lock.release();
+        return model;
+    }
+    async delete(tableName, id) {
+        await this.lock.acquire();
+        if (!this.native.has(tableName))
+            throw new db_decorators_1.NotFoundError(`Table ${tableName} not found`);
+        if (!this.native.get(tableName)?.has(id))
+            throw new db_decorators_1.NotFoundError(`Record with id ${id} not found in table ${tableName}`);
+        const natived = this.native.get(tableName)?.get(id);
+        this.native.get(tableName)?.delete(id);
+        this.lock.release();
+        return natived;
+    }
+    tableFor(from) {
+        if (typeof from === "string")
+            from = decorator_validation_1.Model.get(from);
+        const table = Repository_1.Repository.table(from);
+        if (!this.native.has(table))
+            this.native.set(table, new Map());
+        return this.native.get(table);
+    }
+    async raw(rawInput) {
+        const { where, sort, limit, skip, from } = rawInput;
+        let { select } = rawInput;
+        const collection = this.tableFor(from);
+        if (!collection)
+            throw new db_decorators_1.InternalError(`Table ${from} not found in RamAdapter`);
+        const { id, props } = (0, db_decorators_1.findPrimaryKey)(new from());
+        let result = Array.from(collection.entries()).map(([pk, r]) => this.revert(r, from, id, persistence_1.Sequence.parseValue(props.type, 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;
+    }
+    parseError(err) {
+        if (err instanceof db_decorators_1.BaseError)
+            return err;
+        return new db_decorators_1.InternalError(err);
+    }
+    Statement() {
+        return new RamStatement_1.RamStatement(this);
+    }
+    async Sequence(options) {
+        return new RamSequence_1.RamSequence(options, this);
+    }
+    static decoration() {
+        const createdByKey = Repository_1.Repository.key(persistence_1.PersistenceKeys.CREATED_BY);
+        const updatedByKey = Repository_1.Repository.key(persistence_1.PersistenceKeys.UPDATED_BY);
+        decorator_validation_1.Decoration.flavouredAs(constants_1.RamFlavour)
+            .for(createdByKey)
+            .define((0, db_decorators_1.onCreate)(handlers_1.createdByOnRamCreateUpdate), (0, decorator_validation_1.propMetadata)(createdByKey, {}))
+            .apply();
+        decorator_validation_1.Decoration.flavouredAs(constants_1.RamFlavour)
+            .for(updatedByKey)
+            .define((0, db_decorators_1.onCreate)(handlers_1.createdByOnRamCreateUpdate), (0, decorator_validation_1.propMetadata)(updatedByKey, {}))
+            .apply();
+    }
+}
+exports.RamAdapter = RamAdapter;
+RamAdapter.decoration();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamAdapter.js","sourceRoot":"","sources":["../../src/ram/RamAdapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { RamFlags, RawRamQuery, RamStorage, RamRepository } from \"./types\";\nimport { RamStatement } from \"./RamStatement\";\nimport { RamContext } from \"./RamContext\";\nimport { Repository } from \"../repository/Repository\";\nimport { Adapter, PersistenceKeys, Sequence } from \"../persistence\";\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  findPrimaryKey,\n  InternalError,\n  NotFoundError,\n  onCreate,\n  OperationKeys,\n} from \"@decaf-ts/db-decorators\";\nimport { RamSequence } from \"./RamSequence\";\nimport { createdByOnRamCreateUpdate } from \"./handlers\";\nimport { RamFlavour } from \"./constants\";\n\nexport class RamAdapter extends Adapter<\n  RamStorage,\n  RawRamQuery<any>,\n  RamFlags,\n  RamContext\n> {\n  constructor(alias?: string) {\n    super(new Map<string, Map<string, any>>(), RamFlavour, alias);\n  }\n\n  override repository<M extends Model>(): Constructor<RamRepository<M>> {\n    return super.repository<M>() as Constructor<RamRepository<M>>;\n  }\n\n  override flags<M extends Model>(\n    operation: OperationKeys,\n    model: Constructor<M>,\n    flags: Partial<RamFlags>\n  ): RamFlags {\n    return Object.assign(super.flags(operation, model, flags), {\n      UUID: crypto.randomUUID(),\n    }) as RamFlags;\n  }\n\n  override Context = RamContext;\n\n  private indexes: Record<\n    string,\n    Record<string | number, Record<string, any>>\n  > = {};\n\n  private lock = new Lock();\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  override 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  override 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.has(tableName)) this.native.set(tableName, new Map());\n    if (this.native.get(tableName) && this.native.get(tableName)?.has(id))\n      throw new ConflictError(\n        `Record with id ${id} already exists in table ${tableName}`\n      );\n    this.native.get(tableName)?.set(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 (!this.native.has(tableName))\n      throw new NotFoundError(`Table ${tableName} not found`);\n    if (!this.native.get(tableName)?.has(id))\n      throw new NotFoundError(\n        `Record with id ${id} not found in table ${tableName}`\n      );\n    return this.native.get(tableName)?.get(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 (!this.native.has(tableName))\n      throw new NotFoundError(`Table ${tableName} not found`);\n    if (!this.native.get(tableName)?.has(id))\n      throw new NotFoundError(\n        `Record with id ${id} not found in table ${tableName}`\n      );\n    this.native.get(tableName)?.set(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 (!this.native.has(tableName))\n      throw new NotFoundError(`Table ${tableName} not found`);\n    if (!this.native.get(tableName)?.has(id))\n      throw new NotFoundError(\n        `Record with id ${id} not found in table ${tableName}`\n      );\n    const natived = this.native.get(tableName)?.get(id);\n    this.native.get(tableName)?.delete(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 (!this.native.has(table)) this.native.set(table, new Map());\n    return this.native.get(table);\n  }\n\n  async raw<R>(rawInput: RawRamQuery<any>): Promise<R> {\n    const { where, sort, limit, skip, from } = rawInput;\n    let { select } = rawInput;\n    const collection = this.tableFor(from);\n    if (!collection)\n      throw new InternalError(`Table ${from} not found in RamAdapter`);\n    const { id, props } = findPrimaryKey(new from());\n\n    let result: any[] = Array.from(collection.entries()).map(([pk, r]) =>\n      this.revert(\n        r,\n        from,\n        id as any,\n        Sequence.parseValue(props.type as any, pk as string) as string\n      )\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 R;\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  Statement<M extends Model>(): RamStatement<M, any> {\n    return new RamStatement<M, any>(this as any);\n  }\n\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new RamSequence(options, this);\n  }\n\n  static decoration() {\n    const createdByKey = Repository.key(PersistenceKeys.CREATED_BY);\n    const updatedByKey = Repository.key(PersistenceKeys.UPDATED_BY);\n    Decoration.flavouredAs(RamFlavour)\n      .for(createdByKey)\n      .define(\n        onCreate(createdByOnRamCreateUpdate),\n        propMetadata(createdByKey, {})\n      )\n      .apply();\n    Decoration.flavouredAs(RamFlavour)\n      .for(updatedByKey)\n      .define(\n        onCreate(createdByOnRamCreateUpdate),\n        propMetadata(updatedByKey, {})\n      )\n      .apply();\n  }\n}\n\nRamAdapter.decoration();\n"]}

package/lib/ram/RamAdapter.d.ts

@@ -0,0 +1,32 @@
+import { RamFlags, RawRamQuery, RamStorage, RamRepository } from "./types";
+import { RamStatement } from "./RamStatement";
+import { RamContext } from "./RamContext";
+import { Adapter, Sequence } from "../persistence";
+import { SequenceOptions } from "../interfaces";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { BaseError, OperationKeys } from "@decaf-ts/db-decorators";
+export declare class RamAdapter extends Adapter<RamStorage, RawRamQuery<any>, RamFlags, RamContext> {
+    constructor(alias?: string);
+    repository<M extends Model>(): Constructor<RamRepository<M>>;
+    flags<M extends Model>(operation: OperationKeys, model: Constructor<M>, flags: Partial<RamFlags>): RamFlags;
+    Context: typeof RamContext;
+    private indexes;
+    private lock;
+    initialize(...args: any[]): Promise<void>;
+    index(...models: Record<string, any>[]): Promise<any>;
+    prepare<M extends Model>(model: M, pk: keyof M): {
+        record: Record<string, any>;
+        id: string;
+    };
+    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: keyof M, id: string | number): M;
+    create(tableName: string, id: string | number, model: Record<string, any>): Promise<Record<string, any>>;
+    read(tableName: string, id: string | number): Promise<Record<string, any>>;
+    update(tableName: string, id: string | number, model: Record<string, any>): Promise<Record<string, any>>;
+    delete(tableName: string, id: string | number): Promise<Record<string, any>>;
+    protected tableFor<M extends Model>(from: string | Constructor<M>): Map<string | number, any> | undefined;
+    raw<R>(rawInput: RawRamQuery<any>): Promise<R>;
+    parseError<V extends BaseError>(err: Error): V;
+    Statement<M extends Model>(): RamStatement<M, any>;
+    Sequence(options: SequenceOptions): Promise<Sequence>;
+    static decoration(): void;
+}

package/lib/ram/RamContext.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RamContext = void 0;
+const db_decorators_1 = require("@decaf-ts/db-decorators");
+class RamContext extends db_decorators_1.Context {
+    constructor(obj) {
+        super(obj);
+    }
+}
+exports.RamContext = RamContext;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFtQ29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yYW0vUmFtQ29udGV4dC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSwyREFBa0Q7QUFHbEQsTUFBYSxVQUFXLFNBQVEsdUJBQWlCO0lBQy9DLFlBQVksR0FBYTtRQUN2QixLQUFLLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDYixDQUFDO0NBQ0Y7QUFKRCxnQ0FJQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbnRleHQgfSBmcm9tIFwiQGRlY2FmLXRzL2RiLWRlY29yYXRvcnNcIjtcbmltcG9ydCB7IFJhbUZsYWdzIH0gZnJvbSBcIi4vdHlwZXNcIjtcblxuZXhwb3J0IGNsYXNzIFJhbUNvbnRleHQgZXh0ZW5kcyBDb250ZXh0PFJhbUZsYWdzPiB7XG4gIGNvbnN0cnVjdG9yKG9iajogUmFtRmxhZ3MpIHtcbiAgICBzdXBlcihvYmopO1xuICB9XG59XG4iXX0=

package/lib/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/ram/RamPaginator.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RamPaginator = void 0;
+const query_1 = require("./../query/index.cjs");
+class RamPaginator extends query_1.Paginator {
+    constructor(adapter, query, size, clazz) {
+        super(adapter, query, size, clazz);
+    }
+    prepare(rawStatement) {
+        const query = Object.assign({}, rawStatement);
+        query.limit = this.size;
+        return query;
+    }
+    async page(page = 1) {
+        page = this.validatePage(page);
+        const statement = this.prepare(this.statement);
+        statement.skip = (page - 1) * this.size;
+        const results = await this.adapter.raw(statement);
+        this._currentPage = page;
+        return results;
+    }
+}
+exports.RamPaginator = RamPaginator;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/ram/RamPaginator.d.ts

@@ -0,0 +1,9 @@
+import { RawRamQuery } from "./types";
+import { Paginator } from "../query";
+import { Constructor, Model } from "@decaf-ts/decorator-validation";
+import { Adapter } from "../persistence";
+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>);
+    protected prepare(rawStatement: RawRamQuery<M>): RawRamQuery<M>;
+    page(page?: number): Promise<R[]>;
+}

package/lib/ram/RamSequence.cjs

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RamSequence = void 0;
+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");
+class RamSequence extends persistence_1.Sequence {
+    constructor(options, adapter) {
+        super(options);
+        this.repo = repository_1.Repository.forModel(RamSequence_1.Sequence, adapter.flavour);
+    }
+    async current() {
+        const { name, startWith } = this.options;
+        try {
+            const sequence = await this.repo.read(name);
+            return this.parse(sequence.current);
+        }
+        catch (e) {
+            if (e instanceof db_decorators_1.NotFoundError) {
+                if (typeof startWith === "undefined")
+                    throw new db_decorators_1.InternalError("Starting value is not defined for a non existing sequence");
+                try {
+                    return this.parse(startWith);
+                }
+                catch (e) {
+                    throw new db_decorators_1.InternalError(`Failed to parse initial value for sequence ${startWith}: ${e}`);
+                }
+            }
+            throw new db_decorators_1.InternalError(`Failed to retrieve current value for sequence ${name}: ${e}`);
+        }
+    }
+    parse(value) {
+        return persistence_1.Sequence.parseValue(this.options.type, value);
+    }
+    async increment(current, count) {
+        const { type, incrementBy, name } = this.options;
+        let next;
+        const toIncrementBy = count || incrementBy;
+        if (toIncrementBy % incrementBy !== 0)
+            throw new db_decorators_1.InternalError(`Value to increment does not consider the incrementBy setting: ${incrementBy}`);
+        switch (type) {
+            case "Number":
+                next = this.parse(current) + toIncrementBy;
+                break;
+            case "BigInt":
+                next = this.parse(current) + BigInt(toIncrementBy);
+                break;
+            default:
+                throw new db_decorators_1.InternalError("Should never happen");
+        }
+        let seq;
+        const repo = this.repo.override({
+            ignoredValidationProperties: ["updatedOn"],
+        });
+        try {
+            seq = await repo.update(new RamSequence_1.Sequence({ id: name, current: next }));
+        }
+        catch (e) {
+            if (!(e instanceof db_decorators_1.NotFoundError)) {
+                throw e;
+            }
+            seq = await repo.create(new RamSequence_1.Sequence({ id: name, current: next }));
+        }
+        return seq.current;
+    }
+    async next() {
+        const current = await this.current();
+        return this.increment(current);
+    }
+    async range(count) {
+        const current = (await this.current());
+        const incrementBy = this.parse(this.options.incrementBy);
+        const next = await this.increment(current, this.parse(count) * incrementBy);
+        const range = [];
+        for (let i = 1; i <= count; i++) {
+            range.push(current + incrementBy * this.parse(i));
+        }
+        if (range[range.length - 1] !== next)
+            throw new db_decorators_1.InternalError("Miscalculation of range");
+        return range;
+    }
+}
+exports.RamSequence = RamSequence;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamSequence.js","sourceRoot":"","sources":["../../src/ram/RamSequence.ts"],"names":[],"mappings":";;;AAAA,yDAAsD;AACtD,2DAAuE;AACvE,4DAA0C;AAG1C,0DAAiD;AAEjD,MAAa,WAAY,SAAQ,sBAAQ;IAGvC,YAAY,OAAwB,EAAE,OAAmB;QACvD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAU,CAAC,QAAQ,CAAC,sBAAG,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACxD,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QACzC,IAAI,CAAC;YACH,MAAM,QAAQ,GAAQ,MAAM,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAc,CAAC,CAAC;YAC3D,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAA0B,CAAC,CAAC;QACzD,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,IAAI,CAAC,YAAY,6BAAa,EAAE,CAAC;gBAC/B,IAAI,OAAO,SAAS,KAAK,WAAW;oBAClC,MAAM,IAAI,6BAAa,CACrB,2DAA2D,CAC5D,CAAC;gBACJ,IAAI,CAAC;oBACH,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;gBAC/B,CAAC;gBAAC,OAAO,CAAM,EAAE,CAAC;oBAChB,MAAM,IAAI,6BAAa,CACrB,8CAA8C,SAAS,KAAK,CAAC,EAAE,CAChE,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,MAAM,IAAI,6BAAa,CACrB,iDAAiD,IAAI,KAAK,CAAC,EAAE,CAC9D,CAAC;QACJ,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,KAA+B;QAC3C,OAAO,sBAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IACvD,CAAC;IAEO,KAAK,CAAC,SAAS,CACrB,OAAiC,EACjC,KAAc;QAEd,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QACjD,IAAI,IAA8B,CAAC;QACnC,MAAM,aAAa,GAAG,KAAK,IAAI,WAAW,CAAC;QAC3C,IAAI,aAAa,GAAG,WAAW,KAAK,CAAC;YACnC,MAAM,IAAI,6BAAa,CACrB,iEAAiE,WAAW,EAAE,CAC/E,CAAC;QACJ,QAAQ,IAAI,EAAE,CAAC;YACb,KAAK,QAAQ;gBACX,IAAI,GAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,GAAG,aAAa,CAAC;gBACvD,MAAM;YACR,KAAK,QAAQ;gBACX,IAAI,GAAI,IAAI,CAAC,KAAK,CAAC,OAAO,CAAY,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC;gBAC/D,MAAM;YACR;gBACE,MAAM,IAAI,6BAAa,CAAC,qBAAqB,CAAC,CAAC;QACnD,CAAC;QACD,IAAI,GAAQ,CAAC;QACb,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC;YAC9B,2BAA2B,EAAE,CAAC,WAAW,CAAC;SAC3C,CAAC,CAAC;QACH,IAAI,CAAC;YACH,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,sBAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QAChE,CAAC;QAAC,OAAO,CAAM,EAAE,CAAC;YAChB,IAAI,CAAC,CAAC,CAAC,YAAY,6BAAa,CAAC,EAAE,CAAC;gBAClC,MAAM,CAAC,CAAC;YACV,CAAC;YACD,GAAG,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,IAAI,sBAAG,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;QAChE,CAAC;QAED,OAAO,GAAG,CAAC,OAAmC,CAAC;IACjD,CAAC;IAED,KAAK,CAAC,IAAI;QACR,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,KAAK,CAAC,KAAa;QACvB,MAAM,OAAO,GAAG,CAAC,MAAM,IAAI,CAAC,OAAO,EAAE,CAAW,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,WAAW,CAAW,CAAC;QACnE,MAAM,IAAI,GAA6B,MAAM,IAAI,CAAC,SAAS,CACzD,OAAO,EACN,IAAI,CAAC,KAAK,CAAC,KAAK,CAAY,GAAG,WAAW,CAC5C,CAAC;QACF,MAAM,KAAK,GAAiC,EAAE,CAAC;QAC/C,KAAK,IAAI,CAAC,GAAW,CAAC,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YACxC,KAAK,CAAC,IAAI,CAAC,OAAO,GAAG,WAAW,GAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAY,CAAC,CAAC;QAChE,CAAC;QACD,IAAI,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,KAAK,IAAI;YAClC,MAAM,IAAI,6BAAa,CAAC,yBAAyB,CAAC,CAAC;QACrD,OAAO,KAAK,CAAC;IACf,CAAC;CACF;AA9FD,kCA8FC","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"]}

package/lib/ram/RamSequence.d.ts

@@ -0,0 +1,14 @@
+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 class RamSequence extends Sequence {
+    protected repo: Repo<Seq>;
+    constructor(options: SequenceOptions, adapter: RamAdapter);
+    current(): Promise<string | number | bigint>;
+    private parse;
+    private increment;
+    next(): Promise<number | string | bigint>;
+    range(count: number): Promise<(number | string | bigint)[]>;
+}

package/lib/ram/RamStatement.cjs

@@ -0,0 +1,117 @@
+"use strict";
+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");
+class RamStatement extends Statement_1.Statement {
+    constructor(adapter) {
+        super(adapter);
+    }
+    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}`);
+            }
+        };
+    }
+    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;
+    }
+    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);
+        }
+    }
+    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\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"]}

package/lib/ram/RamStatement.d.ts

@@ -0,0 +1,12 @@
+import { Condition, Paginator } from "../query";
+import { RawRamQuery } from "./types";
+import { Model } from "@decaf-ts/decorator-validation";
+import { Statement } from "../query/Statement";
+import { RamAdapter } from "./RamAdapter";
+export declare class RamStatement<M extends Model, R> extends Statement<RawRamQuery<M>, M, R> {
+    constructor(adapter: RamAdapter);
+    private getSort;
+    protected build(): RawRamQuery<M>;
+    paginate(size: number): Promise<Paginator<M, R, RawRamQuery<M>>>;
+    parseCondition<M extends Model>(condition: Condition<M>): RawRamQuery<M>;
+}

package/lib/ram/constants.cjs

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RamFlavour = void 0;
+exports.RamFlavour = "ram";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JhbS9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQWEsUUFBQSxVQUFVLEdBQUcsS0FBSyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IFJhbUZsYXZvdXIgPSBcInJhbVwiO1xuIl19

package/lib/ram/constants.d.ts

@@ -0,0 +1 @@
+export declare const RamFlavour = "ram";

package/lib/ram/handlers.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createdByOnRamCreateUpdate = createdByOnRamCreateUpdate;
+const persistence_1 = require("./../persistence/index.cjs");
+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==

package/lib/ram/handlers.d.ts

@@ -0,0 +1,6 @@
+import { Model } from "@decaf-ts/decorator-validation";
+import { Repo } from "../repository";
+import { RelationsMetadata } from "../model";
+import { RamFlags } from "./types";
+import { Context } from "@decaf-ts/db-decorators";
+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/index.cjs

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RamAdapter_1 = require("./RamAdapter.cjs");
+// Invoked there to ensure decoration override
+RamAdapter_1.RamAdapter.decoration();
+__exportStar(require("./model/index.cjs"), exports);
+__exportStar(require("./constants.cjs"), exports);
+__exportStar(require("./handlers.cjs"), exports);
+__exportStar(require("./RamContext.cjs"), exports);
+__exportStar(require("./RamPaginator.cjs"), exports);
+__exportStar(require("./RamStatement.cjs"), exports);
+__exportStar(require("./RamSequence.cjs"), exports);
+__exportStar(require("./types.cjs"), exports);
+// left to last on purpose
+__exportStar(require("./RamAdapter.cjs"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmFtL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxpREFBMEM7QUFFMUMsOENBQThDO0FBQzlDLHVCQUFVLENBQUMsVUFBVSxFQUFFLENBQUM7QUFFeEIsb0RBQXdCO0FBQ3hCLGtEQUE0QjtBQUM1QixpREFBMkI7QUFDM0IsbURBQTZCO0FBQzdCLHFEQUErQjtBQUMvQixxREFBK0I7QUFDL0Isb0RBQThCO0FBQzlCLDhDQUF3QjtBQUN4QiwwQkFBMEI7QUFDMUIsbURBQTZCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUmFtQWRhcHRlciB9IGZyb20gXCIuL1JhbUFkYXB0ZXJcIjtcblxuLy8gSW52b2tlZCB0aGVyZSB0byBlbnN1cmUgZGVjb3JhdGlvbiBvdmVycmlkZVxuUmFtQWRhcHRlci5kZWNvcmF0aW9uKCk7XG5cbmV4cG9ydCAqIGZyb20gXCIuL21vZGVsXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jb25zdGFudHNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2hhbmRsZXJzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SYW1Db250ZXh0XCI7XG5leHBvcnQgKiBmcm9tIFwiLi9SYW1QYWdpbmF0b3JcIjtcbmV4cG9ydCAqIGZyb20gXCIuL1JhbVN0YXRlbWVudFwiO1xuZXhwb3J0ICogZnJvbSBcIi4vUmFtU2VxdWVuY2VcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzXCI7XG4vLyBsZWZ0IHRvIGxhc3Qgb24gcHVycG9zZVxuZXhwb3J0ICogZnJvbSBcIi4vUmFtQWRhcHRlclwiO1xuIl19

package/lib/ram/index.d.ts

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