@decaf-ts/core
Version:
Core persistence module for the decaf framework
454 lines • 56.7 kB
JavaScript
"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");
/**
* @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
*/
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();
}
/**
* @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 {Promise<RamFlags>} Complete flags with UUID
*/
async flags(operation, model, flags) {
return Object.assign(await 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.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;
}
/**
* @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 (!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);
}
/**
* @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 (!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;
}
/**
* @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 (!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;
}
/**
* @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 = 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);
}
/**
* @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);
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;
}
/**
* @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 db_decorators_1.BaseError)
return err;
return new db_decorators_1.InternalError(err);
}
/**
* @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_1.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_1.RamSequence(options, this);
}
/**
* @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_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,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