@decaf-ts/core 0.5.0 → 0.5.2

package/lib/esm/ram/RamAdapter.js

@@ -1,139 +1,359 @@
 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 { Adapter, PersistenceKeys, Sequence } from "../persistence";
 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 { BaseError, ConflictError, findPrimaryKey, InternalError, NotFoundError, onCreate, } 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();
+import { createdByOnRamCreateUpdate } from "./handlers";
+import { RamFlavour } from "./constants";
+/**
+ * @description In-memory adapter for data persistence
+ * @summary The RamAdapter provides an in-memory implementation of the persistence layer.
+ * It stores data in JavaScript Maps and provides CRUD operations and query capabilities.
+ * This adapter is useful for testing, prototyping, and applications that don't require
+ * persistent storage across application restarts.
+ * @class RamAdapter
+ * @category Ram
+ * @example
+ * ```typescript
+ * // Create a new RAM adapter
+ * const adapter = new RamAdapter('myRamAdapter');
+ *
+ * // Create a repository for a model
+ * const userRepo = new (adapter.repository<User>())(User, adapter);
+ *
+ * // Perform CRUD operations
+ * const user = new User({ name: 'John', email: 'john@example.com' });
+ * await userRepo.create(user);
+ * const retrievedUser = await userRepo.findById(user.id);
+ * ```
+ * @mermaid
+ * sequenceDiagram
+ *   participant Client
+ *   participant Repository
+ *   participant RamAdapter
+ *   participant Storage as In-Memory Storage
+ *
+ *   Client->>Repository: create(model)
+ *   Repository->>RamAdapter: create(tableName, id, model)
+ *   RamAdapter->>RamAdapter: lock.acquire()
+ *   RamAdapter->>Storage: set(id, model)
+ *   RamAdapter->>RamAdapter: lock.release()
+ *   RamAdapter-->>Repository: model
+ *   Repository-->>Client: model
+ *
+ *   Client->>Repository: findById(id)
+ *   Repository->>RamAdapter: read(tableName, id)
+ *   RamAdapter->>Storage: get(id)
+ *   Storage-->>RamAdapter: model
+ *   RamAdapter-->>Repository: model
+ *   Repository-->>Client: model
+ */
 export class RamAdapter extends Adapter {
-    constructor(flavour = "ram") {
-        super({}, flavour);
+    constructor(alias) {
+        super(new Map(), RamFlavour, alias);
+        this.Context = RamContext;
         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,
+    /**
+     * @description Gets the repository constructor for a model
+     * @summary Returns a constructor for creating repositories that work with the specified model type.
+     * This method overrides the base implementation to provide RAM-specific repository functionality.
+     * @template M - The model type for the repository
+     * @return {Constructor<RamRepository<M>>} A constructor for creating RAM repositories
+     */
+    repository() {
+        return super.repository();
+    }
+    /**
+     * @description Creates operation flags with UUID
+     * @summary Extends the base flags with a UUID for user identification.
+     * This method ensures that all operations have a unique identifier for tracking purposes.
+     * @template M - The model type for the operation
+     * @param {OperationKeys} operation - The type of operation being performed
+     * @param {Constructor<M>} model - The model constructor
+     * @param {Partial<RamFlags>} flags - Partial flags to be extended
+     * @return {RamFlags} Complete flags with UUID
+     */
+    flags(operation, model, flags) {
+        return Object.assign(super.flags(operation, model, flags), {
             UUID: crypto.randomUUID(),
-        }));
+        });
     }
+    /**
+     * @description Initializes the RAM adapter
+     * @summary A no-op initialization method for the RAM adapter.
+     * Since RAM adapter doesn't require any setup, this method simply resolves immediately.
+     * @param {...any[]} args - Initialization arguments (unused)
+     * @return {Promise<void>} A promise that resolves when initialization is complete
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async initialize(...args) {
         return Promise.resolve(undefined);
     }
+    /**
+     * @description Indexes models in the RAM adapter
+     * @summary A no-op indexing method for the RAM adapter.
+     * Since RAM adapter doesn't require explicit indexing, this method simply resolves immediately.
+     * @param models - Models to be indexed (unused)
+     * @return {Promise<any>} A promise that resolves when indexing is complete
+     */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     async index(...models) {
         return Promise.resolve(undefined);
     }
+    /**
+     * @description Prepares a model for storage
+     * @summary Converts a model instance to a format suitable for storage in the RAM adapter.
+     * This method extracts the primary key and creates a record without the primary key field.
+     * @template M - The model type being prepared
+     * @param {M} model - The model instance to prepare
+     * @param pk - The primary key property name
+     * @return Object containing the record and ID
+     */
     prepare(model, pk) {
         const prepared = super.prepare(model, pk);
         delete prepared.record[pk];
         return prepared;
     }
+    /**
+     * @description Converts a stored record back to a model instance
+     * @summary Reconstructs a model instance from a stored record by adding back the primary key.
+     * This method is the inverse of the prepare method.
+     * @template M - The model type to revert to
+     * @param {Record<string, any>} obj - The stored record
+     * @param {string | Constructor<M>} clazz - The model class or name
+     * @param pk - The primary key property name
+     * @param {string | number} id - The primary key value
+     * @return {M} The reconstructed model instance
+     */
     revert(obj, clazz, pk, id) {
         const res = super.revert(obj, clazz, pk, id);
         return res;
     }
+    /**
+     * @description Creates a new record in the in-memory storage
+     * @summary Stores a new record in the specified table with the given ID.
+     * This method acquires a lock to ensure thread safety, creates the table if it doesn't exist,
+     * checks for conflicts, and stores the model.
+     * @param {string} tableName - The name of the table to store the record in
+     * @param {string | number} id - The unique identifier for the record
+     * @param {Record<string, any>} model - The record data to store
+     * @return {Promise<Record<string, any>>} A promise that resolves to the stored record
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RamAdapter
+     *   participant Storage as In-Memory Storage
+     *
+     *   Caller->>RamAdapter: create(tableName, id, model)
+     *   RamAdapter->>RamAdapter: lock.acquire()
+     *   RamAdapter->>Storage: has(tableName)
+     *   alt Table doesn't exist
+     *     RamAdapter->>Storage: set(tableName, new Map())
+     *   end
+     *   RamAdapter->>Storage: has(id)
+     *   alt Record exists
+     *     RamAdapter-->>Caller: throw ConflictError
+     *   end
+     *   RamAdapter->>Storage: set(id, model)
+     *   RamAdapter->>RamAdapter: lock.release()
+     *   RamAdapter-->>Caller: model
+     */
     async create(tableName, id, model) {
         await this.lock.acquire();
-        if (!this.native[tableName])
-            this.native[tableName] = {};
-        if (id in this.native[tableName])
+        if (!this.native.has(tableName))
+            this.native.set(tableName, new Map());
+        if (this.native.get(tableName) && this.native.get(tableName)?.has(id))
             throw new ConflictError(`Record with id ${id} already exists in table ${tableName}`);
-        this.native[tableName][id] = model;
+        this.native.get(tableName)?.set(id, model);
         this.lock.release();
         return model;
     }
+    /**
+     * @description Retrieves a record from in-memory storage
+     * @summary Fetches a record with the specified ID from the given table.
+     * This method checks if the table and record exist and throws appropriate errors if not.
+     * @param {string} tableName - The name of the table to retrieve from
+     * @param {string | number} id - The unique identifier of the record to retrieve
+     * @return {Promise<Record<string, any>>} A promise that resolves to the retrieved record
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RamAdapter
+     *   participant Storage as In-Memory Storage
+     *
+     *   Caller->>RamAdapter: read(tableName, id)
+     *   RamAdapter->>Storage: has(tableName)
+     *   alt Table doesn't exist
+     *     RamAdapter-->>Caller: throw NotFoundError
+     *   end
+     *   RamAdapter->>Storage: has(id)
+     *   alt Record doesn't exist
+     *     RamAdapter-->>Caller: throw NotFoundError
+     *   end
+     *   RamAdapter->>Storage: get(id)
+     *   Storage-->>RamAdapter: record
+     *   RamAdapter-->>Caller: record
+     */
     async read(tableName, id) {
-        if (!(tableName in this.native))
+        if (!this.native.has(tableName))
             throw new NotFoundError(`Table ${tableName} not found`);
-        if (!(id in this.native[tableName]))
+        if (!this.native.get(tableName)?.has(id))
             throw new NotFoundError(`Record with id ${id} not found in table ${tableName}`);
-        return this.native[tableName][id];
+        return this.native.get(tableName)?.get(id);
     }
+    /**
+     * @description Updates an existing record in the in-memory storage
+     * @summary Updates a record with the specified ID in the given table.
+     * This method acquires a lock to ensure thread safety, checks if the table and record exist,
+     * and updates the record with the new data.
+     * @param {string} tableName - The name of the table containing the record
+     * @param {string | number} id - The unique identifier of the record to update
+     * @param {Record<string, any>} model - The new record data
+     * @return {Promise<Record<string, any>>} A promise that resolves to the updated record
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RamAdapter
+     *   participant Storage as In-Memory Storage
+     *
+     *   Caller->>RamAdapter: update(tableName, id, model)
+     *   RamAdapter->>RamAdapter: lock.acquire()
+     *   RamAdapter->>Storage: has(tableName)
+     *   alt Table doesn't exist
+     *     RamAdapter-->>Caller: throw NotFoundError
+     *   end
+     *   RamAdapter->>Storage: has(id)
+     *   alt Record doesn't exist
+     *     RamAdapter-->>Caller: throw NotFoundError
+     *   end
+     *   RamAdapter->>Storage: set(id, model)
+     *   RamAdapter->>RamAdapter: lock.release()
+     *   RamAdapter-->>Caller: model
+     */
     async update(tableName, id, model) {
         await this.lock.acquire();
-        if (!(tableName in this.native))
+        if (!this.native.has(tableName))
             throw new NotFoundError(`Table ${tableName} not found`);
-        if (!(id in this.native[tableName]))
+        if (!this.native.get(tableName)?.has(id))
             throw new NotFoundError(`Record with id ${id} not found in table ${tableName}`);
-        this.native[tableName][id] = model;
+        this.native.get(tableName)?.set(id, model);
         this.lock.release();
         return model;
     }
+    /**
+     * @description Deletes a record from the in-memory storage
+     * @summary Removes a record with the specified ID from the given table.
+     * This method acquires a lock to ensure thread safety, checks if the table and record exist,
+     * retrieves the record before deletion, and then removes it from storage.
+     * @param {string} tableName - The name of the table containing the record
+     * @param {string | number} id - The unique identifier of the record to delete
+     * @return {Promise<Record<string, any>>} A promise that resolves to the deleted record
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RamAdapter
+     *   participant Storage as In-Memory Storage
+     *
+     *   Caller->>RamAdapter: delete(tableName, id)
+     *   RamAdapter->>RamAdapter: lock.acquire()
+     *   RamAdapter->>Storage: has(tableName)
+     *   alt Table doesn't exist
+     *     RamAdapter-->>Caller: throw NotFoundError
+     *   end
+     *   RamAdapter->>Storage: has(id)
+     *   alt Record doesn't exist
+     *     RamAdapter-->>Caller: throw NotFoundError
+     *   end
+     *   RamAdapter->>Storage: get(id)
+     *   Storage-->>RamAdapter: record
+     *   RamAdapter->>Storage: delete(id)
+     *   RamAdapter->>RamAdapter: lock.release()
+     *   RamAdapter-->>Caller: record
+     */
     async delete(tableName, id) {
         await this.lock.acquire();
-        if (!(tableName in this.native))
+        if (!this.native.has(tableName))
             throw new NotFoundError(`Table ${tableName} not found`);
-        if (!(id in this.native[tableName]))
+        if (!this.native.get(tableName)?.has(id))
             throw new NotFoundError(`Record with id ${id} not found in table ${tableName}`);
-        const natived = this.native[tableName][id];
-        delete this.native[tableName][id];
+        const natived = this.native.get(tableName)?.get(id);
+        this.native.get(tableName)?.delete(id);
         this.lock.release();
         return natived;
     }
+    /**
+     * @description Gets or creates a table in the in-memory storage
+     * @summary Retrieves the Map representing a table for a given model or table name.
+     * If the table doesn't exist, it creates a new one. This is a helper method used
+     * by other methods to access the correct storage location.
+     * @template M - The model type for the table
+     * @param {string | Constructor<M>} from - The model class or table name
+     * @return {Map<string | number, any> | undefined} The table Map or undefined
+     */
     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];
+        if (!this.native.has(table))
+            this.native.set(table, new Map());
+        return this.native.get(table);
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async raw(rawInput, process) {
+    /**
+     * @description Executes a raw query against the in-memory storage
+     * @summary Performs a query operation on the in-memory data store using the provided query specification.
+     * This method supports filtering, sorting, pagination, and field selection.
+     * @template R - The return type of the query
+     * @param {RawRamQuery<any>} rawInput - The query specification
+     * @return {Promise<R>} A promise that resolves to the query results
+     * @mermaid
+     * sequenceDiagram
+     *   participant Caller
+     *   participant RamAdapter
+     *   participant Storage as In-Memory Storage
+     *
+     *   Caller->>RamAdapter: raw(rawInput)
+     *   RamAdapter->>RamAdapter: tableFor(from)
+     *   alt Table doesn't exist
+     *     RamAdapter-->>Caller: throw InternalError
+     *   end
+     *   RamAdapter->>RamAdapter: findPrimaryKey(new from())
+     *   RamAdapter->>Storage: entries()
+     *   Storage-->>RamAdapter: entries
+     *   loop For each entry
+     *     RamAdapter->>RamAdapter: revert(r, from, id, pk)
+     *   end
+     *   alt Where condition exists
+     *     RamAdapter->>RamAdapter: result.filter(where)
+     *   end
+     *   alt Sort condition exists
+     *     RamAdapter->>RamAdapter: result.sort(sort)
+     *   end
+     *   alt Skip specified
+     *     RamAdapter->>RamAdapter: result.slice(skip)
+     *   end
+     *   alt Limit specified
+     *     RamAdapter->>RamAdapter: result.slice(0, limit)
+     *   end
+     *   alt Select fields specified
+     *     loop For each result
+     *       RamAdapter->>RamAdapter: Filter to selected fields
+     *     end
+     *   end
+     *   RamAdapter-->>Caller: result
+     */
+    async raw(rawInput) {
         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)));
+        if (!collection)
+            throw new InternalError(`Table ${from} not found in RamAdapter`);
+        const { id, props } = findPrimaryKey(new from());
+        let result = Array.from(collection.entries()).map(([pk, r]) => this.revert(r, from, id, Sequence.parseValue(props.type, pk)));
         result = where ? result.filter(where) : result;
         if (sort)
             result = result.sort(sort);
@@ -151,80 +371,80 @@ export class RamAdapter extends Adapter {
         }
         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);
-    }
+    /**
+     * @description Parses and converts errors to appropriate types
+     * @summary Ensures that errors are of the correct type for consistent error handling.
+     * If the error is already a BaseError, it's returned as is; otherwise, it's wrapped in an InternalError.
+     * @template V - The expected error type, extending BaseError
+     * @param {Error} err - The error to parse
+     * @return {V} The parsed error of the expected type
+     */
     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() {
+    /**
+     * @description Creates a new statement builder for queries
+     * @summary Factory method that creates a new RamStatement instance for building queries.
+     * This method allows for fluent query construction against the RAM adapter.
+     * @template M - The model type for the statement
+     * @return {RamStatement<M, any>} A new statement builder instance
+     */
+    Statement() {
         return new RamStatement(this);
     }
+    /**
+     * @description Creates a new sequence for generating sequential IDs
+     * @summary Factory method that creates a new RamSequence instance for ID generation.
+     * This method provides a way to create auto-incrementing sequences for entity IDs.
+     * @param {SequenceOptions} options - Configuration options for the sequence
+     * @return {Promise<Sequence>} A promise that resolves to the new sequence instance
+     */
     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}`);
-                    }
-                }
-            },
-        };
+    /**
+     * @description Sets up RAM-specific decorations for model properties
+     * @summary Configures decorations for createdBy and updatedBy fields in the RAM adapter.
+     * This static method is called during initialization to set up handlers that automatically
+     * populate these fields with the current user's UUID during create and update operations.
+     * @return {void}
+     * @mermaid
+     * sequenceDiagram
+     *   participant RamAdapter
+     *   participant Decoration
+     *   participant Repository
+     *
+     *   RamAdapter->>Repository: key(PersistenceKeys.CREATED_BY)
+     *   Repository-->>RamAdapter: createdByKey
+     *   RamAdapter->>Repository: key(PersistenceKeys.UPDATED_BY)
+     *   Repository-->>RamAdapter: updatedByKey
+     *
+     *   RamAdapter->>Decoration: flavouredAs(RamFlavour)
+     *   Decoration-->>RamAdapter: DecoratorBuilder
+     *   RamAdapter->>Decoration: for(createdByKey)
+     *   RamAdapter->>Decoration: define(onCreate, propMetadata)
+     *   RamAdapter->>Decoration: apply()
+     *
+     *   RamAdapter->>Decoration: flavouredAs(RamFlavour)
+     *   Decoration-->>RamAdapter: DecoratorBuilder
+     *   RamAdapter->>Decoration: for(updatedByKey)
+     *   RamAdapter->>Decoration: define(onCreate, propMetadata)
+     *   RamAdapter->>Decoration: apply()
+     */
+    static decoration() {
+        const createdByKey = Repository.key(PersistenceKeys.CREATED_BY);
+        const updatedByKey = Repository.key(PersistenceKeys.UPDATED_BY);
+        Decoration.flavouredAs(RamFlavour)
+            .for(createdByKey)
+            .define(onCreate(createdByOnRamCreateUpdate), propMetadata(createdByKey, {}))
+            .apply();
+        Decoration.flavouredAs(RamFlavour)
+            .for(updatedByKey)
+            .define(onCreate(createdByOnRamCreateUpdate), propMetadata(updatedByKey, {}))
+            .apply();
     }
 }
-//# 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"]}
+RamAdapter.decoration();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RamAdapter.js","sourceRoot":"","sources":["../../../src/ram/RamAdapter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAEpE,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAC1D,OAAO,EAEL,UAAU,EACV,KAAK,EACL,YAAY,GACb,MAAM,gCAAgC,CAAC;AACxC,OAAO,EACL,SAAS,EACT,aAAa,EACb,cAAc,EACd,aAAa,EACb,aAAa,EACb,QAAQ,GAET,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,OAAO,UAAW,SAAQ,OAK/B;IACC,YAAY,KAAc;QACxB,KAAK,CAAC,IAAI,GAAG,EAA4B,EAAE,UAAU,EAAE,KAAK,CAAC,CAAC;QAkCvD,YAAO,GAAG,UAAU,CAAC;QAEtB,YAAO,GAGX,EAAE,CAAC;QAEC,SAAI,GAAG,IAAI,IAAI,EAAE,CAAC;IAxC1B,CAAC;IAED;;;;;;OAMG;IACM,UAAU;QACjB,OAAO,KAAK,CAAC,UAAU,EAAsC,CAAC;IAChE,CAAC;IAED;;;;;;;;;OASG;IACM,KAAK,CACZ,SAAwB,EACxB,KAAqB,EACrB,KAAwB;QAExB,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE;YACzD,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE;SAC1B,CAAa,CAAC;IACjB,CAAC;IAWD;;;;;;OAMG;IACH,6DAA6D;IAC7D,KAAK,CAAC,UAAU,CAAC,GAAG,IAAW;QAC7B,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;OAMG;IACH,6DAA6D;IAC7D,KAAK,CAAC,KAAK,CAAC,GAAG,MAA6B;QAC1C,OAAO,OAAO,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACpC,CAAC;IAED;;;;;;;;OAQG;IACM,OAAO,CACd,KAAQ,EACR,EAAW;QAEX,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAC1C,OAAO,QAAQ,CAAC,MAAM,CAAC,EAAY,CAAC,CAAC;QACrC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;;;;;;;OAUG;IACM,MAAM,CACb,GAAwB,EACxB,KAA8B,EAC9B,EAAW,EACX,EAAmB;QAEnB,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;QAC7C,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAAmB,EACnB,KAA0B;QAE1B,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QACvE,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YACnE,MAAM,IAAI,aAAa,CACrB,kBAAkB,EAAE,4BAA4B,SAAS,EAAE,CAC5D,CAAC;QACJ,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH,KAAK,CAAC,IAAI,CACR,SAAiB,EACjB,EAAmB;QAEnB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;YAC7B,MAAM,IAAI,aAAa,CAAC,SAAS,SAAS,YAAY,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,aAAa,CACrB,kBAAkB,EAAE,uBAAuB,SAAS,EAAE,CACvD,CAAC;QACJ,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAAmB,EACnB,KAA0B;QAE1B,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;YAC7B,MAAM,IAAI,aAAa,CAAC,SAAS,SAAS,YAAY,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,aAAa,CACrB,kBAAkB,EAAE,uBAAuB,SAAS,EAAE,CACvD,CAAC;QACJ,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;QAC3C,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH,KAAK,CAAC,MAAM,CACV,SAAiB,EACjB,EAAmB;QAEnB,MAAM,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC;YAC7B,MAAM,IAAI,aAAa,CAAC,SAAS,SAAS,YAAY,CAAC,CAAC;QAC1D,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,IAAI,aAAa,CACrB,kBAAkB,EAAE,uBAAuB,SAAS,EAAE,CACvD,CAAC;QACJ,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QACpD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;QACvC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;QACpB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;;;;;OAQG;IACO,QAAQ,CAAkB,IAA6B;QAC/D,IAAI,OAAO,IAAI,KAAK,QAAQ;YAAE,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,IAAI,CAAmB,CAAC;QACvE,MAAM,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,KAAK,CAAC,GAAG,CAAI,QAA0B;QACrC,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC;QACpD,IAAI,EAAE,MAAM,EAAE,GAAG,QAAQ,CAAC;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,UAAU;YACb,MAAM,IAAI,aAAa,CAAC,SAAS,IAAI,0BAA0B,CAAC,CAAC;QACnE,MAAM,EAAE,EAAE,EAAE,KAAK,EAAE,GAAG,cAAc,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QAEjD,IAAI,MAAM,GAAU,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,CACnE,IAAI,CAAC,MAAM,CACT,CAAC,EACD,IAAI,EACJ,EAAS,EACT,QAAQ,CAAC,UAAU,CAAC,KAAK,CAAC,IAAW,EAAE,EAAY,CAAW,CAC/D,CACF,CAAC;QAEF,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAE/C,IAAI,IAAI;YAAE,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAErC,IAAI,IAAI;YAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,KAAK;YAAE,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAE3C,IAAI,MAAM,EAAE,CAAC;YACX,MAAM,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YACnD,MAAM,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CACxB,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAwB,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE;gBAChE,IAAK,MAAmB,CAAC,QAAQ,CAAC,GAAG,CAAC;oBAAE,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC;gBACvD,OAAO,GAAG,CAAC;YACb,CAAC,EAAE,EAAE,CAAC,CACP,CAAC;QACJ,CAAC;QAED,OAAO,MAAsB,CAAC;IAChC,CAAC;IAED;;;;;;;OAOG;IACH,UAAU,CAAsB,GAAU;QACxC,IAAI,GAAG,YAAY,SAAS;YAAE,OAAO,GAAQ,CAAC;QAC9C,OAAO,IAAI,aAAa,CAAC,GAAG,CAAM,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACH,SAAS;QACP,OAAO,IAAI,YAAY,CAAS,IAAW,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,QAAQ,CAAC,OAAwB;QACrC,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,MAAM,CAAC,UAAU;QACf,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAChE,MAAM,YAAY,GAAG,UAAU,CAAC,GAAG,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;QAChE,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC;aAC/B,GAAG,CAAC,YAAY,CAAC;aACjB,MAAM,CACL,QAAQ,CAAC,0BAA0B,CAAC,EACpC,YAAY,CAAC,YAAY,EAAE,EAAE,CAAC,CAC/B;aACA,KAAK,EAAE,CAAC;QACX,UAAU,CAAC,WAAW,CAAC,UAAU,CAAC;aAC/B,GAAG,CAAC,YAAY,CAAC;aACjB,MAAM,CACL,QAAQ,CAAC,0BAA0B,CAAC,EACpC,YAAY,CAAC,YAAY,EAAE,EAAE,CAAC,CAC/B;aACA,KAAK,EAAE,CAAC;IACb,CAAC;CACF;AAED,UAAU,CAAC,UAAU,EAAE,CAAC","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\n/**\n * @description In-memory adapter for data persistence\n * @summary The RamAdapter provides an in-memory implementation of the persistence layer.\n * It stores data in JavaScript Maps and provides CRUD operations and query capabilities.\n * This adapter is useful for testing, prototyping, and applications that don't require\n * persistent storage across application restarts.\n * @class RamAdapter\n * @category Ram\n * @example\n * ```typescript\n * // Create a new RAM adapter\n * const adapter = new RamAdapter('myRamAdapter');\n *\n * // Create a repository for a model\n * const userRepo = new (adapter.repository<User>())(User, adapter);\n *\n * // Perform CRUD operations\n * const user = new User({ name: 'John', email: 'john@example.com' });\n * await userRepo.create(user);\n * const retrievedUser = await userRepo.findById(user.id);\n * ```\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Repository\n *   participant RamAdapter\n *   participant Storage as In-Memory Storage\n *\n *   Client->>Repository: create(model)\n *   Repository->>RamAdapter: create(tableName, id, model)\n *   RamAdapter->>RamAdapter: lock.acquire()\n *   RamAdapter->>Storage: set(id, model)\n *   RamAdapter->>RamAdapter: lock.release()\n *   RamAdapter-->>Repository: model\n *   Repository-->>Client: model\n *\n *   Client->>Repository: findById(id)\n *   Repository->>RamAdapter: read(tableName, id)\n *   RamAdapter->>Storage: get(id)\n *   Storage-->>RamAdapter: model\n *   RamAdapter-->>Repository: model\n *   Repository-->>Client: model\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  /**\n   * @description Gets the repository constructor for a model\n   * @summary Returns a constructor for creating repositories that work with the specified model type.\n   * This method overrides the base implementation to provide RAM-specific repository functionality.\n   * @template M - The model type for the repository\n   * @return {Constructor<RamRepository<M>>} A constructor for creating RAM repositories\n   */\n  override repository<M extends Model>(): Constructor<RamRepository<M>> {\n    return super.repository<M>() as Constructor<RamRepository<M>>;\n  }\n\n  /**\n   * @description Creates operation flags with UUID\n   * @summary Extends the base flags with a UUID for user identification.\n   * This method ensures that all operations have a unique identifier for tracking purposes.\n   * @template M - The model type for the operation\n   * @param {OperationKeys} operation - The type of operation being performed\n   * @param {Constructor<M>} model - The model constructor\n   * @param {Partial<RamFlags>} flags - Partial flags to be extended\n   * @return {RamFlags} Complete flags with UUID\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  /**\n   * @description Initializes the RAM adapter\n   * @summary A no-op initialization method for the RAM adapter.\n   * Since RAM adapter doesn't require any setup, this method simply resolves immediately.\n   * @param {...any[]} args - Initialization arguments (unused)\n   * @return {Promise<void>} A promise that resolves when initialization is complete\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  /**\n   * @description Indexes models in the RAM adapter\n   * @summary A no-op indexing method for the RAM adapter.\n   * Since RAM adapter doesn't require explicit indexing, this method simply resolves immediately.\n   * @param models - Models to be indexed (unused)\n   * @return {Promise<any>} A promise that resolves when indexing is complete\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  /**\n   * @description Prepares a model for storage\n   * @summary Converts a model instance to a format suitable for storage in the RAM adapter.\n   * This method extracts the primary key and creates a record without the primary key field.\n   * @template M - The model type being prepared\n   * @param {M} model - The model instance to prepare\n   * @param pk - The primary key property name\n   * @return Object containing the record and ID\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  /**\n   * @description Converts a stored record back to a model instance\n   * @summary Reconstructs a model instance from a stored record by adding back the primary key.\n   * This method is the inverse of the prepare method.\n   * @template M - The model type to revert to\n   * @param {Record<string, any>} obj - The stored record\n   * @param {string | Constructor<M>} clazz - The model class or name\n   * @param pk - The primary key property name\n   * @param {string | number} id - The primary key value\n   * @return {M} The reconstructed model instance\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  /**\n   * @description Creates a new record in the in-memory storage\n   * @summary Stores a new record in the specified table with the given ID.\n   * This method acquires a lock to ensure thread safety, creates the table if it doesn't exist,\n   * checks for conflicts, and stores the model.\n   * @param {string} tableName - The name of the table to store the record in\n   * @param {string | number} id - The unique identifier for the record\n   * @param {Record<string, any>} model - The record data to store\n   * @return {Promise<Record<string, any>>} A promise that resolves to the stored record\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant RamAdapter\n   *   participant Storage as In-Memory Storage\n   *\n   *   Caller->>RamAdapter: create(tableName, id, model)\n   *   RamAdapter->>RamAdapter: lock.acquire()\n   *   RamAdapter->>Storage: has(tableName)\n   *   alt Table doesn't exist\n   *     RamAdapter->>Storage: set(tableName, new Map())\n   *   end\n   *   RamAdapter->>Storage: has(id)\n   *   alt Record exists\n   *     RamAdapter-->>Caller: throw ConflictError\n   *   end\n   *   RamAdapter->>Storage: set(id, model)\n   *   RamAdapter->>RamAdapter: lock.release()\n   *   RamAdapter-->>Caller: model\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  /**\n   * @description Retrieves a record from in-memory storage\n   * @summary Fetches a record with the specified ID from the given table.\n   * This method checks if the table and record exist and throws appropriate errors if not.\n   * @param {string} tableName - The name of the table to retrieve from\n   * @param {string | number} id - The unique identifier of the record to retrieve\n   * @return {Promise<Record<string, any>>} A promise that resolves to the retrieved record\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant RamAdapter\n   *   participant Storage as In-Memory Storage\n   *\n   *   Caller->>RamAdapter: read(tableName, id)\n   *   RamAdapter->>Storage: has(tableName)\n   *   alt Table doesn't exist\n   *     RamAdapter-->>Caller: throw NotFoundError\n   *   end\n   *   RamAdapter->>Storage: has(id)\n   *   alt Record doesn't exist\n   *     RamAdapter-->>Caller: throw NotFoundError\n   *   end\n   *   RamAdapter->>Storage: get(id)\n   *   Storage-->>RamAdapter: record\n   *   RamAdapter-->>Caller: record\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  /**\n   * @description Updates an existing record in the in-memory storage\n   * @summary Updates a record with the specified ID in the given table.\n   * This method acquires a lock to ensure thread safety, checks if the table and record exist,\n   * and updates the record with the new data.\n   * @param {string} tableName - The name of the table containing the record\n   * @param {string | number} id - The unique identifier of the record to update\n   * @param {Record<string, any>} model - The new record data\n   * @return {Promise<Record<string, any>>} A promise that resolves to the updated record\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant RamAdapter\n   *   participant Storage as In-Memory Storage\n   *\n   *   Caller->>RamAdapter: update(tableName, id, model)\n   *   RamAdapter->>RamAdapter: lock.acquire()\n   *   RamAdapter->>Storage: has(tableName)\n   *   alt Table doesn't exist\n   *     RamAdapter-->>Caller: throw NotFoundError\n   *   end\n   *   RamAdapter->>Storage: has(id)\n   *   alt Record doesn't exist\n   *     RamAdapter-->>Caller: throw NotFoundError\n   *   end\n   *   RamAdapter->>Storage: set(id, model)\n   *   RamAdapter->>RamAdapter: lock.release()\n   *   RamAdapter-->>Caller: model\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  /**\n   * @description Deletes a record from the in-memory storage\n   * @summary Removes a record with the specified ID from the given table.\n   * This method acquires a lock to ensure thread safety, checks if the table and record exist,\n   * retrieves the record before deletion, and then removes it from storage.\n   * @param {string} tableName - The name of the table containing the record\n   * @param {string | number} id - The unique identifier of the record to delete\n   * @return {Promise<Record<string, any>>} A promise that resolves to the deleted record\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant RamAdapter\n   *   participant Storage as In-Memory Storage\n   *\n   *   Caller->>RamAdapter: delete(tableName, id)\n   *   RamAdapter->>RamAdapter: lock.acquire()\n   *   RamAdapter->>Storage: has(tableName)\n   *   alt Table doesn't exist\n   *     RamAdapter-->>Caller: throw NotFoundError\n   *   end\n   *   RamAdapter->>Storage: has(id)\n   *   alt Record doesn't exist\n   *     RamAdapter-->>Caller: throw NotFoundError\n   *   end\n   *   RamAdapter->>Storage: get(id)\n   *   Storage-->>RamAdapter: record\n   *   RamAdapter->>Storage: delete(id)\n   *   RamAdapter->>RamAdapter: lock.release()\n   *   RamAdapter-->>Caller: record\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  /**\n   * @description Gets or creates a table in the in-memory storage\n   * @summary Retrieves the Map representing a table for a given model or table name.\n   * If the table doesn't exist, it creates a new one. This is a helper method used\n   * by other methods to access the correct storage location.\n   * @template M - The model type for the table\n   * @param {string | Constructor<M>} from - The model class or table name\n   * @return {Map<string | number, any> | undefined} The table Map or undefined\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  /**\n   * @description Executes a raw query against the in-memory storage\n   * @summary Performs a query operation on the in-memory data store using the provided query specification.\n   * This method supports filtering, sorting, pagination, and field selection.\n   * @template R - The return type of the query\n   * @param {RawRamQuery<any>} rawInput - The query specification\n   * @return {Promise<R>} A promise that resolves to the query results\n   * @mermaid\n   * sequenceDiagram\n   *   participant Caller\n   *   participant RamAdapter\n   *   participant Storage as In-Memory Storage\n   *\n   *   Caller->>RamAdapter: raw(rawInput)\n   *   RamAdapter->>RamAdapter: tableFor(from)\n   *   alt Table doesn't exist\n   *     RamAdapter-->>Caller: throw InternalError\n   *   end\n   *   RamAdapter->>RamAdapter: findPrimaryKey(new from())\n   *   RamAdapter->>Storage: entries()\n   *   Storage-->>RamAdapter: entries\n   *   loop For each entry\n   *     RamAdapter->>RamAdapter: revert(r, from, id, pk)\n   *   end\n   *   alt Where condition exists\n   *     RamAdapter->>RamAdapter: result.filter(where)\n   *   end\n   *   alt Sort condition exists\n   *     RamAdapter->>RamAdapter: result.sort(sort)\n   *   end\n   *   alt Skip specified\n   *     RamAdapter->>RamAdapter: result.slice(skip)\n   *   end\n   *   alt Limit specified\n   *     RamAdapter->>RamAdapter: result.slice(0, limit)\n   *   end\n   *   alt Select fields specified\n   *     loop For each result\n   *       RamAdapter->>RamAdapter: Filter to selected fields\n   *     end\n   *   end\n   *   RamAdapter-->>Caller: result\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  /**\n   * @description Parses and converts errors to appropriate types\n   * @summary Ensures that errors are of the correct type for consistent error handling.\n   * If the error is already a BaseError, it's returned as is; otherwise, it's wrapped in an InternalError.\n   * @template V - The expected error type, extending BaseError\n   * @param {Error} err - The error to parse\n   * @return {V} The parsed error of the expected type\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  /**\n   * @description Creates a new statement builder for queries\n   * @summary Factory method that creates a new RamStatement instance for building queries.\n   * This method allows for fluent query construction against the RAM adapter.\n   * @template M - The model type for the statement\n   * @return {RamStatement<M, any>} A new statement builder instance\n   */\n  Statement<M extends Model>(): RamStatement<M, any> {\n    return new RamStatement<M, any>(this as any);\n  }\n\n  /**\n   * @description Creates a new sequence for generating sequential IDs\n   * @summary Factory method that creates a new RamSequence instance for ID generation.\n   * This method provides a way to create auto-incrementing sequences for entity IDs.\n   * @param {SequenceOptions} options - Configuration options for the sequence\n   * @return {Promise<Sequence>} A promise that resolves to the new sequence instance\n   */\n  async Sequence(options: SequenceOptions): Promise<Sequence> {\n    return new RamSequence(options, this);\n  }\n\n  /**\n   * @description Sets up RAM-specific decorations for model properties\n   * @summary Configures decorations for createdBy and updatedBy fields in the RAM adapter.\n   * This static method is called during initialization to set up handlers that automatically\n   * populate these fields with the current user's UUID during create and update operations.\n   * @return {void}\n   * @mermaid\n   * sequenceDiagram\n   *   participant RamAdapter\n   *   participant Decoration\n   *   participant Repository\n   *\n   *   RamAdapter->>Repository: key(PersistenceKeys.CREATED_BY)\n   *   Repository-->>RamAdapter: createdByKey\n   *   RamAdapter->>Repository: key(PersistenceKeys.UPDATED_BY)\n   *   Repository-->>RamAdapter: updatedByKey\n   *\n   *   RamAdapter->>Decoration: flavouredAs(RamFlavour)\n   *   Decoration-->>RamAdapter: DecoratorBuilder\n   *   RamAdapter->>Decoration: for(createdByKey)\n   *   RamAdapter->>Decoration: define(onCreate, propMetadata)\n   *   RamAdapter->>Decoration: apply()\n   *\n   *   RamAdapter->>Decoration: flavouredAs(RamFlavour)\n   *   Decoration-->>RamAdapter: DecoratorBuilder\n   *   RamAdapter->>Decoration: for(updatedByKey)\n   *   RamAdapter->>Decoration: define(onCreate, propMetadata)\n   *   RamAdapter->>Decoration: apply()\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"]}