@decaf-ts/core 0.7.1 → 0.7.3

package/lib/esm/persistence/Adapter.d.ts

@@ -1,19 +1,20 @@
-import { BaseError, Context, OperationKeys, RepositoryFlags, Contextual, BulkCrudOperationKeys } from "@decaf-ts/db-decorators";
+import { BaseError, Context, OperationKeys, Contextual, BulkCrudOperationKeys, PrimaryKeyType } from "@decaf-ts/db-decorators";
 import { type Observer } from "../interfaces/Observer";
 import { Model, ModelConstructor } from "@decaf-ts/decorator-validation";
 import { SequenceOptions } from "../interfaces/SequenceOptions";
 import { RawExecutor } from "../interfaces/RawExecutor";
-import { Observable } from "../interfaces/Observable";
 import type { Repository } from "../repository/Repository";
 import { Sequence } from "./Sequence";
 import { ErrorParser } from "../interfaces";
 import { Statement } from "../query/Statement";
 import type { Dispatch } from "./Dispatch";
-import { type EventIds, Migration, type ObserverFilter } from "./types";
+import { type EventIds, FlagsOf, Migration, type ObserverFilter, PersistenceObservable, PersistenceObserver, PreparedModel } from "./types";
 import { ObserverHandler } from "./ObserverHandler";
-import { LoggedClass } from "@decaf-ts/logging";
+import { Impersonatable } from "@decaf-ts/logging";
 import { AdapterDispatch } from "./types";
 import { type Constructor } from "@decaf-ts/decoration";
+import { ContextualArgs, ContextualizedArgs, ContextualLoggedClass } from "../utils/ContextualLoggedClass";
+export type AdapterSubClass<A> = A extends Adapter<any, any, any, any> ? A : never;
 /**
  * @description Abstract Facade class for persistence adapters
  * @summary Provides the foundation for all database adapters in the persistence layer. This class
@@ -106,7 +107,7 @@ import { type Constructor } from "@decaf-ts/decoration";
  *   Adapter --|> Observer
  *   Adapter --|> ErrorParser
  */
-export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends RepositoryFlags = RepositoryFlags, CONTEXT extends Context<FLAGS> = Context<FLAGS>> extends LoggedClass implements RawExecutor<QUERY>, Contextual<FLAGS, CONTEXT>, Observable, Observer, ErrorParser {
+export declare abstract class Adapter<CONF, CONN, QUERY, CONTEXT extends Context<any> = Context> extends ContextualLoggedClass<CONTEXT> implements RawExecutor<QUERY>, Contextual<CONTEXT>, PersistenceObservable<CONTEXT>, PersistenceObserver<CONTEXT>, Impersonatable<any, [Partial<CONF>, ...any[]]>, ErrorParser {
     private readonly _config;
     readonly flavour: string;
     private readonly _alias?;
@@ -114,7 +115,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
     private static _cache;
     private static _baseRepository;
     private static _baseDispatch;
-    protected dispatch?: AdapterDispatch;
+    protected dispatch?: AdapterDispatch<typeof this>;
     protected readonly observerHandler?: ObserverHandler;
     protected _client?: CONN;
     /**
@@ -134,9 +135,9 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @description Gets the repository constructor for this adapter
      * @summary Returns the constructor for creating repositories that work with this adapter
      * @template M - The model type
-     * @return {Constructor<Repository<M, QUERY, Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT>, FLAGS, CONTEXT>>} The repository constructor
+     * @return {Constructor<Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>} The repository constructor
      */
-    repository<M extends Model<boolean>>(): Constructor<Repository<M, QUERY, Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT>, FLAGS, CONTEXT>>;
+    repository<R extends Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>(): Constructor<R>;
     protected shutdownProxies(k?: string): Promise<void>;
     /**
      * @description Shuts down the adapter
@@ -156,13 +157,13 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @template M - The model type
      * @return {Statement} A statement builder for the model
      */
-    abstract Statement<M extends Model>(): Statement<QUERY, M, any>;
+    abstract Statement<M extends Model>(): Statement<M, Adapter<CONF, CONN, QUERY, CONTEXT>, any>;
     /**
      * @description Creates a new dispatch instance
      * @summary Factory method that creates a dispatch instance for this adapter
      * @return {Dispatch} A new dispatch instance
      */
-    protected Dispatch(): Dispatch;
+    protected Dispatch(): Dispatch<Adapter<CONF, CONN, QUERY, CONTEXT>>;
     /**
      * @description Creates a new observer handler
      * @summary Factory method that creates an observer handler for this adapter
@@ -180,9 +181,10 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @description Parses a database error into a standardized error
      * @summary Converts database-specific errors into standardized application errors
      * @param {Error} err - The original database error
+     * @param args
      * @return {BaseError} A standardized error
      */
-    abstract parseError(err: Error): BaseError;
+    abstract parseError<E extends BaseError>(err: Error, ...args: any[]): E;
     /**
      * @description Initializes the adapter
      * @summary Performs any necessary setup for the adapter, such as establishing connections
@@ -208,18 +210,12 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments
      * @return {Promise<F>} The complete set of flags
      */
-    protected flags<M extends Model>(operation: OperationKeys, model: Constructor<M>, flags: Partial<FLAGS>, ...args: any[]): Promise<FLAGS>;
+    protected flags<M extends Model>(operation: OperationKeys | string, model: Constructor<M> | Constructor<M>[], flags: Partial<FlagsOf<CONTEXT>>, ...args: any[]): Promise<FlagsOf<CONTEXT>>;
     /**
      * @description The context constructor for this adapter
      * @summary Reference to the context class constructor used by this adapter
      */
-    protected Context: {
-        new (): Context<FLAGS>;
-        factory: import("@decaf-ts/db-decorators").ContextFactory<any>;
-        childFrom<F extends RepositoryFlags, C extends Context<F>>(context: C, overrides?: Partial<F>): C;
-        from<M extends Model, F extends RepositoryFlags, C extends Context<F>>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, overrides: Partial<F>, model: Constructor<M>, ...args: any[]): Promise<C>;
-        args<M extends Model<any>, C extends Context<F>, F extends RepositoryFlags>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, model: Constructor<M>, args: any[], contextual?: Contextual<F>, overrides?: Partial<F>): Promise<import("@decaf-ts/db-decorators").ContextArgs<F, C>>;
-    };
+    protected readonly Context: Constructor<CONTEXT>;
     /**
      * @description Creates a context for a database operation
      * @summary Generates a context object that describes a database operation, used for tracking and auditing
@@ -231,44 +227,42 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments
      * @return {Promise<C>} A promise that resolves to the context object
      */
-    context<M extends Model>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE, overrides: Partial<FLAGS>, model: Constructor<M>, ...args: any[]): Promise<CONTEXT>;
+    context<M extends Model>(operation: OperationKeys.CREATE | OperationKeys.READ | OperationKeys.UPDATE | OperationKeys.DELETE | string, overrides: Partial<FlagsOf<CONTEXT>>, model: Constructor<M> | Constructor<M>[], ...args: any[]): Promise<CONTEXT>;
     /**
      * @description Prepares a model for persistence
      * @summary Converts a model instance into a format suitable for database storage,
      * handling column mapping and separating transient properties
+     * handling column mapping and separating transient properties
      * @template M - The model type
      * @param {M} model - The model instance to prepare
-     * @param pk - The primary key property name
+     * @param args - optional args for subclassing purposes
      * @return The prepared data
      */
-    prepare<M extends Model>(model: M, pk: keyof M): {
-        record: Record<string, any>;
-        id: string;
-        transient?: Record<string, any>;
-    };
+    prepare<M extends Model>(model: M, ...args: ContextualArgs<CONTEXT>): PreparedModel;
     /**
      * @description Converts database data back into a model instance
      * @summary Reconstructs a model instance from database data, handling column mapping
      * and reattaching transient properties
      * @template M - The model type
      * @param obj - The database record
-     * @param {string|Constructor<M>} clazz - The model class or name
+     * @param {Constructor<M>} clazz - The model class or name
      * @param pk - The primary key property name
      * @param {string|number|bigint} id - The primary key value
      * @param [transient] - Transient properties to reattach
+     * @param [args] - options args for subclassing purposes
      * @return {M} The reconstructed model instance
      */
-    revert<M extends Model>(obj: Record<string, any>, clazz: string | Constructor<M>, pk: keyof M, id: string | number | bigint, transient?: Record<string, any>): M;
+    revert<M extends Model>(obj: Record<string, any>, clazz: Constructor<M>, id: PrimaryKeyType, transient?: Record<string, any>, ...args: ContextualArgs<CONTEXT>): M;
     /**
      * @description Creates a new record in the database
      * @summary Inserts a new record with the given ID and data into the specified table
-     * @param {string} tableName - The name of the table to insert into
-     * @param {string|number} id - The identifier for the new record
+     * @param {string} clazz - The name of the table to insert into
+     * @param {PrimaryKeyType} id - The identifier for the new record
      * @param model - The data to insert
      * @param {any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to the created record
      */
-    abstract create(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    abstract create<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>>;
     /**
      * @description Creates multiple records in the database
      * @summary Inserts multiple records with the given IDs and data into the specified table
@@ -278,7 +272,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of created records
      */
-    createAll(tableName: string, id: (string | number)[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    createAll<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>[]>;
     /**
      * @description Retrieves a record from the database
      * @summary Fetches a record with the given ID from the specified table
@@ -287,7 +281,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to the retrieved record
      */
-    abstract read(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
+    abstract read<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>>;
     /**
      * @description Retrieves multiple records from the database
      * @summary Fetches multiple records with the given IDs from the specified table
@@ -296,27 +290,28 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of retrieved records
      */
-    readAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
+    readAll<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType[], ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>[]>;
     /**
      * @description Updates a record in the database
      * @summary Modifies an existing record with the given ID in the specified table
-     * @param {string} tableName - The name of the table to update
-     * @param {string|number} id - The identifier of the record to update
+     * @template M - The model type
+     * @param {Constructor<M>} tableName - The name of the table to update
+     * @param {PrimaryKeyType} id - The identifier of the record to update
      * @param  model - The new data for the record
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to the updated record
      */
-    abstract update(tableName: string, id: string | number, model: Record<string, any>, ...args: any[]): Promise<Record<string, any>>;
+    abstract update<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType, model: Record<string, any>, ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>>;
     /**
      * @description Updates multiple records in the database
      * @summary Modifies multiple existing records with the given IDs in the specified table
-     * @param {string} tableName - The name of the table to update
+     * @param {Constructor<M>} tableName - The name of the table to update
      * @param {string[]|number[]} id - The identifiers of the records to update
      * @param model - The new data for each record
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of updated records
      */
-    updateAll(tableName: string, id: string[] | number[], model: Record<string, any>[], ...args: any[]): Promise<Record<string, any>[]>;
+    updateAll<M extends Model>(clazz: Constructor<M>, id: PrimaryKeyType[], model: Record<string, any>[], ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>[]>;
     /**
      * @description Deletes a record from the database
      * @summary Removes a record with the given ID from the specified table
@@ -325,7 +320,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to the deleted record
      */
-    abstract delete(tableName: string, id: string | number | bigint, ...args: any[]): Promise<Record<string, any>>;
+    abstract delete<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType, ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>>;
     /**
      * @description Deletes multiple records from the database
      * @summary Removes multiple records with the given IDs from the specified table
@@ -334,7 +329,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of deleted records
      */
-    deleteAll(tableName: string, id: (string | number | bigint)[], ...args: any[]): Promise<Record<string, any>[]>;
+    deleteAll<M extends Model>(tableName: Constructor<M>, id: PrimaryKeyType[], ...args: ContextualArgs<CONTEXT>): Promise<Record<string, any>[]>;
     /**
      * @description Executes a raw query against the database
      * @summary Allows executing database-specific queries directly
@@ -344,7 +339,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return {Promise<R>} A promise that resolves to the query result
      */
-    abstract raw<R>(rawInput: QUERY, ...args: any[]): Promise<R>;
+    abstract raw<R>(rawInput: QUERY, ...args: ContextualArgs<CONTEXT>): Promise<R>;
     /**
      * @description Registers an observer for database events
      * @summary Adds an observer to be notified about database changes. The observer can optionally
@@ -371,7 +366,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments to pass to the observers
      * @return {Promise<void>} A promise that resolves when all observers have been notified
      */
-    updateObservers(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
+    updateObservers<M extends Model>(table: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<CONTEXT>): Promise<void>;
     /**
      * @description Refreshes data based on a database event
      * @summary Implementation of the Observer interface method that delegates to updateObservers
@@ -381,7 +376,7 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @param {...any[]} args - Additional arguments related to the event
      * @return {Promise<void>} A promise that resolves when the refresh is complete
      */
-    refresh(table: string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: any[]): Promise<void>;
+    refresh<M extends Model>(table: Constructor<M> | string, event: OperationKeys | BulkCrudOperationKeys | string, id: EventIds, ...args: ContextualArgs<CONTEXT>): Promise<void>;
     /**
      * @description Gets a string representation of the adapter
      * @summary Returns a human-readable string identifying this adapter
@@ -409,12 +404,11 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      * @template CONF - The database driver config
      * @template CONN - The database driver instance
      * @template QUERY - The query type
-     * @template CCONTEXT - The context type
-     * @template FLAGS - The repository flags type
+     * @template CONTEXT - The context type
      * @param {string} flavour - The flavor name of the adapter to retrieve
-     * @return {Adapter<CONF, CONN, QUERY, CONTEXT, FLAGS> | undefined} The adapter instance or undefined if not found
+     * @return {Adapter<CONF, CONN, QUERY, CONTEXT> | undefined} The adapter instance or undefined if not found
      */
-    static get<CONF, CONN, QUERY, CONTEXT extends Context<FLAGS>, FLAGS extends RepositoryFlags>(flavour?: any): Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT> | undefined;
+    static get<A extends Adapter<any, any, any, any>>(flavour?: any): A | undefined;
     /**
      * @description Sets the current default adapter
      * @summary Changes which adapter is used as the default for operations
@@ -431,6 +425,14 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      */
     static models<M extends Model>(flavour: string): ModelConstructor<M>[];
     static decoration(): void;
+    /**
+     * @description retrieves the context from args and returns it, the logger and the args (with context at the end)
+     * @summary NOTE: if the last argument was a context, this removes the context from the arg list
+     * @param args
+     * @param method
+     */
+    static logCtx<CONTEXT extends Context<any>, ARGS extends any[] = any[]>(this: any, args: ARGS, method: string): ContextualizedArgs<CONTEXT, ARGS>;
+    static logCtx<CONTEXT extends Context<any>, ARGS extends any[] = any[]>(this: any, args: ARGS, method: (...args: any[]) => any): ContextualizedArgs<CONTEXT, ARGS>;
     protected proxies?: Record<string, typeof this>;
     /**
      * @description Returns the client instance for the adapter
@@ -445,7 +447,8 @@ export declare abstract class Adapter<CONF, CONN, QUERY, FLAGS extends Repositor
      */
     protected abstract getClient(): CONN;
     get client(): CONN;
-    for(config: Partial<CONF>, ...args: any[]): typeof this;
-    migrations(): Constructor<Migration<any, this, unknown, unknown, unknown, RepositoryFlags, Context<RepositoryFlags>>>[];
-    migrate(migrations?: Constructor<Migration<any, any, any, any, any>>[]): Promise<void>;
+    for(config: Partial<CONF>, ...args: any[]): this;
+    migrations(): Constructor<Migration<any, this>>[];
+    protected getQueryRunner(): Promise<CONN>;
+    migrate(...args: [...any[], CONTEXT]): Promise<void>;
 }

package/lib/esm/persistence/Adapter.js

@@ -10,12 +10,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { InternalError, Context, OperationKeys, DefaultRepositoryFlags, } from "@decaf-ts/db-decorators";
 import { hashObj, Model, } from "@decaf-ts/decorator-validation";
 import { PersistenceKeys } from "./constants.js";
-import { final } from "./../utils/index.js";
+import { final } from "@decaf-ts/logging";
 import { ObserverHandler } from "./ObserverHandler.js";
-import { LoggedClass } from "@decaf-ts/logging";
-import { getColumnName, getTableName } from "./../identity/utils.js";
+import { Logging } from "@decaf-ts/logging";
 import { Decoration, DefaultFlavour, Metadata, } from "@decaf-ts/decoration";
 import { MigrationError } from "./errors.js";
+import { ContextualLoggedClass, } from "./../utils/ContextualLoggedClass.js";
 const flavourResolver = Decoration["flavourResolver"].bind(Decoration);
 Decoration["flavourResolver"] = (obj) => {
     try {
@@ -135,7 +135,7 @@ Decoration["flavourResolver"] = (obj) => {
  *   Adapter --|> Observer
  *   Adapter --|> ErrorParser
  */
-export class Adapter extends LoggedClass {
+export class Adapter extends ContextualLoggedClass {
     static { this._cache = {}; }
     /**
      * @description Gets the native persistence config
@@ -158,7 +158,7 @@ export class Adapter extends LoggedClass {
      * @description Gets the repository constructor for this adapter
      * @summary Returns the constructor for creating repositories that work with this adapter
      * @template M - The model type
-     * @return {Constructor<Repository<M, QUERY, Adapter<CONF, CONN, QUERY, FLAGS, CONTEXT>, FLAGS, CONTEXT>>} The repository constructor
+     * @return {Constructor<Repository<any, Adapter<CONF, CONN, QUERY, CONTEXT>>>} The repository constructor
      */
     repository() {
         if (!Adapter._baseRepository)
@@ -273,12 +273,18 @@ export class Adapter extends LoggedClass {
     async flags(operation, model, flags, 
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     ...args) {
+        let log = (flags.logger || Logging.for(this.toString()));
+        if (flags.correlationId)
+            log = log.for({ correlationId: flags.correlationId });
         return Object.assign({}, DefaultRepositoryFlags, flags, {
-            affectedTables: getTableName(model),
+            affectedTables: (Array.isArray(model) ? model : [model]).map(Model.tableName),
             writeOperation: operation !== OperationKeys.READ,
             timestamp: new Date(),
             operation: operation,
-            ignoredValidationProperties: Metadata.validationExceptions(model, operation),
+            ignoredValidationProperties: Array.isArray(model)
+                ? []
+                : Metadata.validationExceptions(model, operation),
+            logger: log,
         });
     }
     /**
@@ -294,7 +300,7 @@ export class Adapter extends LoggedClass {
      */
     async context(operation, overrides, model, ...args) {
         const log = this.log.for(this.context);
-        log.debug(`Creating new context for ${operation} operation on ${model.name} model with flag overrides: ${JSON.stringify(overrides)}`);
+        log.debug(`Creating new context for ${operation} operation on ${Array.isArray(model) ? model.map((m) => m.name) : model.name} model with flag overrides: ${JSON.stringify(overrides)}`);
         const flags = await this.flags(operation, model, overrides, ...args);
         return new this.Context().accumulate(flags);
     }
@@ -302,35 +308,37 @@ export class Adapter extends LoggedClass {
      * @description Prepares a model for persistence
      * @summary Converts a model instance into a format suitable for database storage,
      * handling column mapping and separating transient properties
+     * handling column mapping and separating transient properties
      * @template M - The model type
      * @param {M} model - The model instance to prepare
-     * @param pk - The primary key property name
+     * @param args - optional args for subclassing purposes
      * @return The prepared data
      */
-    prepare(model, pk) {
-        const log = this.log.for(this.prepare);
+    prepare(model, ...args) {
+        const { log } = this.logCtx(args, this.prepare);
         const split = model.segregate();
         const result = Object.entries(split.model).reduce((accum, [key, val]) => {
             if (typeof val === "undefined")
                 return accum;
-            const mappedProp = getColumnName(model, key);
+            const mappedProp = Model.columnName(model.constructor, key);
             if (this.isReserved(mappedProp))
                 throw new InternalError(`Property name ${mappedProp} is reserved`);
             accum[mappedProp] = val;
             return accum;
         }, {});
         if (model[PersistenceKeys.METADATA]) {
+            // TODO movo to couchdb
             log.silly(`Passing along persistence metadata for ${model[PersistenceKeys.METADATA]}`);
             Object.defineProperty(result, PersistenceKeys.METADATA, {
                 enumerable: false,
-                writable: false,
+                writable: true,
                 configurable: true,
                 value: model[PersistenceKeys.METADATA],
             });
         }
         return {
             record: result,
-            id: model[pk],
+            id: model[Model.pk(model.constructor)],
             transient: split.transient,
         };
     }
@@ -340,26 +348,29 @@ export class Adapter extends LoggedClass {
      * and reattaching transient properties
      * @template M - The model type
      * @param obj - The database record
-     * @param {string|Constructor<M>} clazz - The model class or name
+     * @param {Constructor<M>} clazz - The model class or name
      * @param pk - The primary key property name
      * @param {string|number|bigint} id - The primary key value
      * @param [transient] - Transient properties to reattach
+     * @param [args] - options args for subclassing purposes
      * @return {M} The reconstructed model instance
      */
-    revert(obj, clazz, pk, id, transient) {
-        const log = this.log.for(this.revert);
+    revert(obj, clazz, id, transient, ...args) {
+        const { log, ctx } = this.logCtx(args, this.revert);
         const ob = {};
+        const pk = Model.pk(clazz);
         ob[pk] = id;
-        const m = (typeof clazz === "string" ? Model.build(ob, clazz) : new clazz(ob));
+        const m = new clazz(ob);
         log.silly(`Rebuilding model ${m.constructor.name} id ${id}`);
-        const metadata = obj[PersistenceKeys.METADATA];
+        const metadata = obj[PersistenceKeys.METADATA]; // TODO move to couchdb
         const result = Object.keys(m).reduce((accum, key) => {
             if (key === pk)
                 return accum;
-            accum[key] = obj[getColumnName(accum, key)];
+            accum[key] =
+                obj[Model.columnName(clazz, key)];
             return accum;
         }, m);
-        if (transient) {
+        if (ctx.get("rebuildWithTransient") && transient) {
             log.verbose(`re-adding transient properties: ${Object.keys(transient).join(", ")}`);
             Object.entries(transient).forEach(([key, val]) => {
                 if (key in result)
@@ -368,11 +379,12 @@ export class Adapter extends LoggedClass {
             });
         }
         if (metadata) {
+            // TODO move to couchdb
             log.silly(`Passing along ${this.flavour} persistence metadata for ${m.constructor.name} id ${id}: ${metadata}`);
             Object.defineProperty(result, PersistenceKeys.METADATA, {
                 enumerable: false,
-                configurable: false,
-                writable: false,
+                configurable: true,
+                writable: true,
                 value: metadata,
             });
         }
@@ -387,13 +399,13 @@ export class Adapter extends LoggedClass {
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of created records
      */
-    async createAll(tableName, id, model, ...args) {
+    async createAll(clazz, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
-        const log = this.log.for(this.createAll);
-        log.verbose(`Creating ${id.length} entries ${tableName} table`);
-        log.debug(`pks: ${id}`);
-        return Promise.all(id.map((i, count) => this.create(tableName, i, model[count], ...args)));
+        const { log, ctxArgs } = this.logCtx(args, this.createAll);
+        const tableLabel = Model.tableName(clazz);
+        log.debug(`Creating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.create(clazz, i, model[count], ...ctxArgs)));
     }
     /**
      * @description Retrieves multiple records from the database
@@ -403,28 +415,28 @@ export class Adapter extends LoggedClass {
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of retrieved records
      */
-    async readAll(tableName, id, ...args) {
-        const log = this.log.for(this.readAll);
-        log.verbose(`Reading ${id.length} entries ${tableName} table`);
-        log.debug(`pks: ${id}`);
-        return Promise.all(id.map((i) => this.read(tableName, i, ...args)));
+    async readAll(clazz, id, ...args) {
+        const { log, ctxArgs } = this.logCtx(args, this.readAll);
+        const tableName = Model.tableName(clazz);
+        log.debug(`Reading ${id.length} entries ${tableName} table`);
+        return Promise.all(id.map((i) => this.read(clazz, i, ...ctxArgs)));
     }
     /**
      * @description Updates multiple records in the database
      * @summary Modifies multiple existing records with the given IDs in the specified table
-     * @param {string} tableName - The name of the table to update
+     * @param {Constructor<M>} tableName - The name of the table to update
      * @param {string[]|number[]} id - The identifiers of the records to update
      * @param model - The new data for each record
      * @param {...any[]} args - Additional arguments specific to the adapter implementation
      * @return A promise that resolves to an array of updated records
      */
-    async updateAll(tableName, id, model, ...args) {
+    async updateAll(clazz, id, model, ...args) {
         if (id.length !== model.length)
             throw new InternalError("Ids and models must have the same length");
-        const log = this.log.for(this.updateAll);
-        log.verbose(`Updating ${id.length} entries ${tableName} table`);
-        log.debug(`pks: ${id}`);
-        return Promise.all(id.map((i, count) => this.update(tableName, i, model[count], ...args)));
+        const { log, ctxArgs } = this.logCtx(args, this.updateAll);
+        const tableLabel = Model.tableName(clazz);
+        log.debug(`Updating ${id.length} entries ${tableLabel} table`);
+        return Promise.all(id.map((i, count) => this.update(clazz, i, model[count], ...ctxArgs)));
     }
     /**
      * @description Deletes multiple records from the database
@@ -435,10 +447,9 @@ export class Adapter extends LoggedClass {
      * @return A promise that resolves to an array of deleted records
      */
     async deleteAll(tableName, id, ...args) {
-        const log = this.log.for(this.createAll);
-        log.verbose(`Deleting ${id.length} entries ${tableName} table`);
-        log.debug(`pks: ${id}`);
-        return Promise.all(id.map((i) => this.delete(tableName, i, ...args)));
+        const { log, ctxArgs } = Adapter.logCtx(args, this.deleteAll);
+        log.verbose(`Deleting ${id.length} entries from ${tableName} table`);
+        return Promise.all(id.map((i) => this.delete(tableName, i, ...ctxArgs)));
     }
     /**
      * @description Registers an observer for database events
@@ -455,11 +466,10 @@ export class Adapter extends LoggedClass {
                 writable: false,
             });
         this.observerHandler.observe(observer, filter);
-        this.log
-            .for(this.observe)
-            .verbose(`Registering new observer ${observer.toString()}`);
+        const log = this.log.for(this.observe);
+        log.verbose(`Registering new observer ${observer.toString()}`);
         if (!this.dispatch) {
-            this.log.for(this.observe).info(`Creating dispatch for ${this.alias}`);
+            log.info(`Creating dispatch for ${this.alias}`);
             this.dispatch = this.Dispatch();
             this.dispatch.observe(this);
         }
@@ -491,9 +501,9 @@ export class Adapter extends LoggedClass {
     async updateObservers(table, event, id, ...args) {
         if (!this.observerHandler)
             throw new InternalError("ObserverHandler not initialized. Did you register any observables?");
-        const log = this.log.for(this.updateObservers);
-        log.verbose(`Updating ${this.observerHandler.count()} observers for adapter ${this.alias}`);
-        await this.observerHandler.updateObservers(this.log, table, event, id, ...args);
+        const { log, ctxArgs } = Adapter.logCtx(args, this.updateObservers);
+        log.verbose(`Updating ${this.observerHandler.count()} observers for adapter ${this.alias}: Event: `);
+        await this.observerHandler.updateObservers(table, event, id, ...ctxArgs);
     }
     /**
      * @description Refreshes data based on a database event
@@ -513,7 +523,7 @@ export class Adapter extends LoggedClass {
      * @return {string} A string representation of the adapter
      */
     toString() {
-        return `${this.flavour} persistence Adapter`;
+        return `${this.flavour} adapter`;
     }
     /**
      * @description Gets the adapter flavor associated with a model
@@ -544,10 +554,9 @@ export class Adapter extends LoggedClass {
      * @template CONF - The database driver config
      * @template CONN - The database driver instance
      * @template QUERY - The query type
-     * @template CCONTEXT - The context type
-     * @template FLAGS - The repository flags type
+     * @template CONTEXT - The context type
      * @param {string} flavour - The flavor name of the adapter to retrieve
-     * @return {Adapter<CONF, CONN, QUERY, CONTEXT, FLAGS> | undefined} The adapter instance or undefined if not found
+     * @return {Adapter<CONF, CONN, QUERY, CONTEXT> | undefined} The adapter instance or undefined if not found
      */
     static get(flavour) {
         if (!flavour)
@@ -581,6 +590,9 @@ export class Adapter extends LoggedClass {
         }
     }
     static decoration() { }
+    static logCtx(args, method) {
+        return super.logCtx(args, method);
+    }
     get client() {
         if (!this._client) {
             this._client = this.getClient();
@@ -620,12 +632,21 @@ export class Adapter extends LoggedClass {
     migrations() {
         return Metadata.migrationsFor(this);
     }
-    async migrate(migrations = this.migrations()) {
+    async getQueryRunner() {
+        return this;
+    }
+    async migrate(migrations = this.migrations(), ...args) {
+        if (migrations instanceof Context) {
+            args = [migrations];
+            migrations = this.migrations();
+        }
+        const { ctx } = Adapter.logCtx(args, this.migrate);
+        const qr = await this.getQueryRunner();
         for (const migration of migrations) {
             try {
                 const m = new migration();
-                await m.up(this, this, this.log);
-                await m.down(this, this, this.log);
+                await m.up(qr, this, ctx);
+                await m.down(qr, this, ctx);
             }
             catch (e) {
                 throw new MigrationError(e);