@magek/common 0.0.6 → 0.0.7

package/dist/concepts/projection-metadata.d.ts

@@ -8,8 +8,8 @@ export interface ProjectionMetadata<TEntity extends EntityInterface, TReadModel
     methodName: string;
     joinKey: keyof TEntity | ReadModelJoinKeyFunction<TEntity, TReadModel>;
 }
-export type ProjectionResult<TReadModel> = TReadModel | ReadModelAction;
-export declare enum ReadModelAction {
-    Delete = 0,
-    Nothing = 1
+export type ProjectionResult<TReadModel> = TReadModel | ProjectionAction;
+export declare enum ProjectionAction {
+    Skip = 0,
+    Delete = 1
 }

package/dist/concepts/projection-metadata.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReadModelAction = void 0;
-var ReadModelAction;
-(function (ReadModelAction) {
-    ReadModelAction[ReadModelAction["Delete"] = 0] = "Delete";
-    ReadModelAction[ReadModelAction["Nothing"] = 1] = "Nothing";
-})(ReadModelAction || (exports.ReadModelAction = ReadModelAction = {}));
+exports.ProjectionAction = void 0;
+var ProjectionAction;
+(function (ProjectionAction) {
+    ProjectionAction[ProjectionAction["Skip"] = 0] = "Skip";
+    ProjectionAction[ProjectionAction["Delete"] = 1] = "Delete";
+})(ProjectionAction || (exports.ProjectionAction = ProjectionAction = {}));

package/dist/concepts/reducer-metadata.d.ts

@@ -1,5 +1,10 @@
 import { AnyClass } from '..';
+import { EntityInterface } from './entity';
 export interface ReducerMetadata {
     class: AnyClass;
     methodName: string;
 }
+export declare enum ReducerAction {
+    Skip = 0
+}
+export type ReducerResult<TEntity extends EntityInterface> = TEntity | ReducerAction;

package/dist/concepts/reducer-metadata.js

@@ -1,2 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReducerAction = void 0;
+var ReducerAction;
+(function (ReducerAction) {
+    ReducerAction[ReducerAction["Skip"] = 0] = "Skip";
+})(ReducerAction || (exports.ReducerAction = ReducerAction = {}));

package/dist/concepts/register.js

@@ -23,6 +23,12 @@ exports.Register = void 0;
  * ```
  */
 class Register {
+    requestID;
+    responseHeaders;
+    flusher;
+    currentUser;
+    context;
+    eventList = [];
     /**
      * Creates a new instance of Register
      *
@@ -56,7 +62,6 @@ class Register {
         this.flusher = flusher;
         this.currentUser = currentUser;
         this.context = context;
-        this.eventList = [];
     }
     /**
      * Register a list of events to be added to the event-store on handler completion

package/dist/config.js

@@ -9,74 +9,83 @@ const _1 = require(".");
  * the Magek config.
  */
 class MagekConfig {
+    environmentName;
+    logLevel = logger_1.Level.debug;
+    logPrefix;
+    logger;
+    _runtime;
+    eventStoreAdapter;
+    readModelStoreAdapter;
+    sessionStoreAdapter;
+    appName = 'new-magek-app';
+    assets;
+    defaultResponseHeaders = {};
+    subscriptions = {
+        maxConnectionDurationInSeconds: 7 * 24 * 60 * 60, // 7 days
+        maxDurationInSeconds: 2 * 24 * 60 * 60, // 2 days
+    };
+    enableGraphQLIntrospection = true;
+    _userProjectRootPath;
+    codeRelativePath = 'dist';
+    eventDispatcherHandler = path.join(this.codeRelativePath, 'index.eventDispatcher');
+    eventStreamConsumer = path.join(this.codeRelativePath, 'index.consumeEventStream');
+    eventStreamProducer = path.join(this.codeRelativePath, 'index.produceEventStream');
+    serveGraphQLHandler = path.join(this.codeRelativePath, 'index.graphQLDispatcher');
+    sensorHealthHandler = path.join(this.codeRelativePath, 'index.health');
+    scheduledTaskHandler = path.join(this.codeRelativePath, 'index.triggerScheduledCommands');
+    notifySubscribersHandler = path.join(this.codeRelativePath, 'index.notifySubscribers');
+    functionRelativePath = path.join('..', this.codeRelativePath, 'index.js');
+    events = {};
+    notifications = {};
+    partitionKeys = {};
+    topicToEvent = {};
+    eventToTopic = {};
+    entities = {};
+    reducers = {};
+    commandHandlers = {};
+    queryHandlers = {};
+    eventHandlers = {};
+    readModels = {};
+    projections = {};
+    unProjections = {};
+    readModelSequenceKeys = {};
+    roles = {};
+    schemaMigrations = {};
+    scheduledCommandHandlers = {};
+    dataMigrationHandlers = {};
+    userHealthIndicators = {};
+    sensorConfiguration = {
+        health: {
+            globalAuthorizer: {
+                authorize: 'all',
+            },
+            magek: _1.DEFAULT_SENSOR_HEALTH_CONFIGURATIONS,
+        },
+    };
+    globalErrorsHandler;
+    enableSubscriptions = true;
+    nonExposedGraphQLMetadataKey = {};
+    // TTL for events stored in dispatched events table. Default to 5 minutes (i.e., 300 seconds).
+    dispatchedEventsTtl = 300;
+    traceConfiguration = {
+        enableTraceNotification: false,
+        includeInternal: false,
+        onStart: async () => { },
+        onEnd: async () => { },
+    };
+    eventStreamConfiguration = { enabled: false };
+    /** Environment variables to set when running the application */
+    env = {};
+    /**
+     * Add `TokenVerifier` implementations to this array to enable token verification.
+     * When a bearer token arrives in a request 'Authorization' header, it will be checked
+     * against all the verifiers registered here.
+     */
+    tokenVerifiers = [];
     constructor(environmentName) {
         this.environmentName = environmentName;
-        this.logLevel = logger_1.Level.debug;
-        this.appName = 'new-magek-app';
-        this.defaultResponseHeaders = {};
-        this.subscriptions = {
-            maxConnectionDurationInSeconds: 7 * 24 * 60 * 60, // 7 days
-            maxDurationInSeconds: 2 * 24 * 60 * 60, // 2 days
-        };
-        this.enableGraphQLIntrospection = true;
-        this.codeRelativePath = 'dist';
-        this.eventDispatcherHandler = path.join(this.codeRelativePath, 'index.eventDispatcher');
-        this.eventStreamConsumer = path.join(this.codeRelativePath, 'index.consumeEventStream');
-        this.eventStreamProducer = path.join(this.codeRelativePath, 'index.produceEventStream');
-        this.serveGraphQLHandler = path.join(this.codeRelativePath, 'index.graphQLDispatcher');
-        this.sensorHealthHandler = path.join(this.codeRelativePath, 'index.health');
-        this.scheduledTaskHandler = path.join(this.codeRelativePath, 'index.triggerScheduledCommands');
-        this.notifySubscribersHandler = path.join(this.codeRelativePath, 'index.notifySubscribers');
-        this.functionRelativePath = path.join('..', this.codeRelativePath, 'index.js');
-        this.events = {};
-        this.notifications = {};
-        this.partitionKeys = {};
-        this.topicToEvent = {};
-        this.eventToTopic = {};
-        this.entities = {};
-        this.reducers = {};
-        this.commandHandlers = {};
-        this.queryHandlers = {};
-        this.eventHandlers = {};
-        this.readModels = {};
-        this.projections = {};
-        this.unProjections = {};
-        this.readModelSequenceKeys = {};
-        this.roles = {};
-        this.schemaMigrations = {};
-        this.scheduledCommandHandlers = {};
-        this.dataMigrationHandlers = {};
-        this.userHealthIndicators = {};
-        this.sensorConfiguration = {
-            health: {
-                globalAuthorizer: {
-                    authorize: 'all',
-                },
-                magek: _1.DEFAULT_SENSOR_HEALTH_CONFIGURATIONS,
-            },
-        };
-        this.enableSubscriptions = true;
-        this.nonExposedGraphQLMetadataKey = {};
-        // TTL for events stored in dispatched events table. Default to 5 minutes (i.e., 300 seconds).
-        this.dispatchedEventsTtl = 300;
-        this.traceConfiguration = {
-            enableTraceNotification: false,
-            includeInternal: false,
-            onStart: async () => { },
-            onEnd: async () => { },
-        };
-        this.eventStreamConfiguration = { enabled: false };
-        /** Environment variables to set when running the application */
-        this.env = {};
-        /**
-         * Add `TokenVerifier` implementations to this array to enable token verification.
-         * When a bearer token arrives in a request 'Authorization' header, it will be checked
-         * against all the verifiers registered here.
-         */
-        this.tokenVerifiers = [];
     }
     get resourceNames() {
-        var _a, _b;
         if (this.appName.length === 0)
             throw new Error('Application name cannot be empty');
         const applicationStackName = this.appName + '-app';
@@ -87,7 +96,7 @@ class MagekConfig {
             eventsDedup: applicationStackName + '-events-dedup',
             subscriptionsStore: applicationStackName + '-subscriptions-store',
             connectionsStore: applicationStackName + '-connections-store',
-            streamTopic: (_b = (_a = this.eventStreamConfiguration.parameters) === null || _a === void 0 ? void 0 : _a.streamTopic) !== null && _b !== void 0 ? _b : 'magek_events',
+            streamTopic: this.eventStreamConfiguration.parameters?.streamTopic ?? 'magek_events',
             forReadModel(readModelName) {
                 return applicationStackName + '-' + readModelName;
             },

package/dist/envelope.d.ts

@@ -36,6 +36,7 @@ export interface EventStoreEntryEnvelope extends TypedEnvelope {
 }
 export interface NonPersistedEventEnvelope extends EventStoreEntryEnvelope {
     kind: 'event';
+    createdAt: string;
 }
 export interface EventEnvelope extends NonPersistedEventEnvelope {
     id?: string;

package/dist/errors/command-handler-global-error.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandHandlerGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class CommandHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    commandEnvelope;
+    commandMetadata;
     constructor(commandEnvelope, commandMetadata, originalError) {
         super(originalError);
         this.commandEnvelope = commandEnvelope;

package/dist/errors/event-global-error.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class EventGlobalError extends global_error_container_1.GlobalErrorContainer {
+    eventEnvelope;
     constructor(eventEnvelope, originalError) {
         super(originalError);
         this.eventEnvelope = eventEnvelope;

package/dist/errors/event-handler-global-error.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventHandlerGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class EventHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    eventEnvelope;
+    eventInstance;
+    eventHandlerMetadata;
     constructor(eventEnvelope, eventInstance, eventHandlerMetadata, originalError) {
         super(originalError);
         this.eventEnvelope = eventEnvelope;

package/dist/errors/global-error-container.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlobalErrorContainer = void 0;
 class GlobalErrorContainer {
+    originalError;
     constructor(originalError) {
         this.originalError = originalError;
     }

package/dist/errors/projection-global-error.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProjectionGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class ProjectionGlobalError extends global_error_container_1.GlobalErrorContainer {
+    entityEnvelope;
+    entity;
+    readModel;
+    projectionMetadata;
     constructor(entityEnvelope, entity, readModel, projectionMetadata, originalError) {
         super(originalError);
         this.entityEnvelope = entityEnvelope;

package/dist/errors/query-handler-global-error.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueryHandlerGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class QueryHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    query;
     constructor(query, originalError) {
         super(originalError);
         this.query = query;

package/dist/errors/reducer-global-error.js

@@ -3,6 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReducerGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class ReducerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    eventEnvelope;
+    eventInstance;
+    snapshotInstance;
+    reducerMetadata;
     constructor(eventEnvelope, eventInstance, snapshotInstance, reducerMetadata, originalError) {
         super(originalError);
         this.eventEnvelope = eventEnvelope;

package/dist/errors/schedule-command-global-error.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScheduleCommandGlobalError = void 0;
 const global_error_container_1 = require("./global-error-container");
 class ScheduleCommandGlobalError extends global_error_container_1.GlobalErrorContainer {
+    scheduleCommandEnvelope;
+    scheduleCommandMetadata;
     constructor(scheduleCommandEnvelope, scheduleCommandMetadata, originalError) {
         super(originalError);
         this.scheduleCommandEnvelope = scheduleCommandEnvelope;

package/dist/errors/snapshot-persist-handler-global-error.js

@@ -13,6 +13,7 @@ const global_error_container_1 = require("./global-error-container");
  * This class is kept for backwards compatibility.
  */
 class SnapshotPersistHandlerGlobalError extends global_error_container_1.GlobalErrorContainer {
+    snapshot;
     constructor(snapshot, originalError) {
         super(originalError);
         this.snapshot = snapshot;

package/dist/errors.js

@@ -3,10 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.InvalidReducerError = exports.InvalidEventError = exports.OptimisticConcurrencyUnexpectedVersionError = exports.InvalidVersionError = exports.NotFoundError = exports.MagekTokenNotBeforeError = exports.MagekTokenExpiredError = exports.NotAuthorizedError = exports.InvalidProtocolError = exports.InvalidParameterError = exports.MagekError = void 0;
 exports.httpStatusCodeFor = httpStatusCodeFor;
 class MagekError extends Error {
+    data;
+    code;
     constructor(message, code, data) {
         super(message);
         this.data = data;
-        this.code = code !== null && code !== void 0 ? code : this.constructor.name;
+        this.code = code ?? this.constructor.name;
     }
 }
 exports.MagekError = MagekError;
@@ -38,6 +40,8 @@ class InvalidEventError extends MagekError {
 }
 exports.InvalidEventError = InvalidEventError;
 class InvalidReducerError extends MagekError {
+    eventInstance;
+    snapshotInstance;
     constructor(message, eventInstance, snapshotInstance) {
         super(message);
         this.eventInstance = eventInstance;
@@ -46,7 +50,6 @@ class InvalidReducerError extends MagekError {
 }
 exports.InvalidReducerError = InvalidReducerError;
 function httpStatusCodeFor(error) {
-    var _a;
     const errorToHTTPCode = {
         [InvalidParameterError.name]: 400,
         [InvalidProtocolError.name]: 400,
@@ -56,5 +59,5 @@ function httpStatusCodeFor(error) {
         [NotFoundError.name]: 404,
         [InvalidVersionError.name]: 422,
     };
-    return (_a = errorToHTTPCode[error.constructor.name]) !== null && _a !== void 0 ? _a : 500;
+    return errorToHTTPCode[error.constructor.name] ?? 500;
 }

package/dist/graphql-websocket-messages.js

@@ -15,38 +15,42 @@ var MessageTypes;
     MessageTypes["GQL_STOP"] = "stop";
 })(MessageTypes || (exports.MessageTypes = MessageTypes = {}));
 class GraphQLInitError {
+    payload;
+    type = MessageTypes.GQL_CONNECTION_ERROR;
     constructor(payload) {
         this.payload = payload;
-        this.type = MessageTypes.GQL_CONNECTION_ERROR;
     }
 }
 exports.GraphQLInitError = GraphQLInitError;
 class GraphQLInitAck {
-    constructor() {
-        this.type = MessageTypes.GQL_CONNECTION_ACK;
-    }
+    type = MessageTypes.GQL_CONNECTION_ACK;
 }
 exports.GraphQLInitAck = GraphQLInitAck;
 class GraphQLData {
+    id;
+    payload;
+    type = MessageTypes.GQL_DATA;
     constructor(id, payload) {
         this.id = id;
         this.payload = payload;
-        this.type = MessageTypes.GQL_DATA;
     }
 }
 exports.GraphQLData = GraphQLData;
 class GraphQLError {
+    id;
+    payload;
+    type = MessageTypes.GQL_ERROR;
     constructor(id, payload) {
         this.id = id;
         this.payload = payload;
-        this.type = MessageTypes.GQL_ERROR;
     }
 }
 exports.GraphQLError = GraphQLError;
 class GraphQLComplete {
+    id;
+    type = MessageTypes.GQL_COMPLETE;
     constructor(id) {
         this.id = id;
-        this.type = MessageTypes.GQL_COMPLETE;
     }
 }
 exports.GraphQLComplete = GraphQLComplete;

package/dist/http-service.js

@@ -23,7 +23,7 @@ async function request(url, method = 'GET', data = '', config = {}) {
             const body = [];
             res.on('data', (chunk) => body.push(chunk));
             res.on('end', () => {
-                if (!(res === null || res === void 0 ? void 0 : res.statusCode)) {
+                if (!res?.statusCode) {
                     return reject(new Error('Unknown HTTP status code'));
                 }
                 // Accept 2xx codes or any explicitly accepted status codes
@@ -32,7 +32,7 @@ async function request(url, method = 'GET', data = '', config = {}) {
                 }
                 const buffer = Buffer.concat(body).toString();
                 resolve({
-                    status: res === null || res === void 0 ? void 0 : res.statusCode,
+                    status: res?.statusCode,
                     body: buffer,
                 });
             });

package/dist/index.d.ts

@@ -26,5 +26,5 @@ export * from './runtime';
 export * from './event-store-adapter';
 export * from './read-model-store-adapter';
 export * from './session-store-adapter';
-export * from './field-decorator';
 export * from './metadata-types';
+export * from './timestamp-generator';

package/dist/index.js

@@ -29,5 +29,5 @@ tslib_1.__exportStar(require("./runtime"), exports);
 tslib_1.__exportStar(require("./event-store-adapter"), exports);
 tslib_1.__exportStar(require("./read-model-store-adapter"), exports);
 tslib_1.__exportStar(require("./session-store-adapter"), exports);
-tslib_1.__exportStar(require("./field-decorator"), exports);
 tslib_1.__exportStar(require("./metadata-types"), exports);
+tslib_1.__exportStar(require("./timestamp-generator"), exports);

package/dist/instances.d.ts

@@ -37,6 +37,26 @@ export declare function createInstance<T>(instanceClass: Class<T>, rawObject: Re
  * @see {@link createInstance}
  */
 export declare function createInstances<T>(instanceClass: Class<T>, rawObjects: Array<Record<string, any>>): T[];
+/**
+ * Applies partial changes to an entity, optionally using defaults when creating a new instance.
+ * Designed for plain objects (entity state); use `createInstance` for class instances.
+ *
+ * @remarks
+ * This function always returns a shallow copy, ensuring immutability.
+ *
+ * @example
+ * ```typescript
+ * // Update existing entity
+ * const updated = evolve(current, { balance: current.balance + event.amount })
+ * // Create new entity with defaults
+ * const created = evolve(undefined, { id: event.entityId, name: event.name }, { status: 'active' })
+ * // Create new entity without defaults (changes must be complete)
+ * const created = evolve(undefined, { id: event.entityId, name: event.name, status: 'active' })
+ * ```
+ */
+export declare function evolve<T extends object>(current: T, changes: Partial<T>): T;
+export declare function evolve<C extends object, D extends object>(current: undefined, changes: C, defaults: D): C & D;
+export declare function evolve<T extends object>(current: undefined, changes: T): T;
 /**
  * Creates an instance of the read model class with the calculated properties included
  * @param instanceClass The read model class

package/dist/instances.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInstance = createInstance;
 exports.createInstances = createInstances;
+exports.evolve = evolve;
 exports.createInstanceWithCalculatedProperties = createInstanceWithCalculatedProperties;
 /**
  * Creates an instance of the given class from the given raw object.
@@ -44,6 +45,15 @@ function createInstance(instanceClass, rawObject) {
 function createInstances(instanceClass, rawObjects) {
     return rawObjects.map((rawObject) => createInstance(instanceClass, rawObject));
 }
+function evolve(current, changes, defaults) {
+    if (current !== undefined) {
+        return { ...current, ...changes };
+    }
+    if (defaults !== undefined) {
+        return { ...defaults, ...changes };
+    }
+    return { ...changes };
+}
 /**
  * Creates an instance of the read model class with the calculated properties included
  * @param instanceClass The read model class

package/dist/logger.js

@@ -11,12 +11,11 @@ var Level;
 })(Level || (exports.Level = Level = {}));
 const defaultLogPrefix = 'Magek';
 function getLogger(config, location, overridenLogPrefix) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
-    const debug = (_b = (_a = config.logger) === null || _a === void 0 ? void 0 : _a.debug) !== null && _b !== void 0 ? _b : console.debug;
-    const info = (_d = (_c = config.logger) === null || _c === void 0 ? void 0 : _c.info) !== null && _d !== void 0 ? _d : console.info;
-    const warn = (_f = (_e = config.logger) === null || _e === void 0 ? void 0 : _e.warn) !== null && _f !== void 0 ? _f : console.warn;
-    const error = (_h = (_g = config.logger) === null || _g === void 0 ? void 0 : _g.error) !== null && _h !== void 0 ? _h : console.error;
-    const logPrefix = (_j = overridenLogPrefix !== null && overridenLogPrefix !== void 0 ? overridenLogPrefix : config === null || config === void 0 ? void 0 : config.logPrefix) !== null && _j !== void 0 ? _j : defaultLogPrefix;
+    const debug = config.logger?.debug ?? console.debug;
+    const info = config.logger?.info ?? console.info;
+    const warn = config.logger?.warn ?? console.warn;
+    const error = config.logger?.error ?? console.error;
+    const logPrefix = overridenLogPrefix ?? config?.logPrefix ?? defaultLogPrefix;
     const locationStr = location ? `|${location}: ` : ': ';
     const prefix = `[${logPrefix}]${locationStr}`;
     const prefixedDebugFunction = debug.bind(null, prefix);

package/dist/metadata-types.d.ts

@@ -2,6 +2,26 @@ import 'reflect-metadata';
 export type ClassType = {
     new (...args: unknown[]): unknown;
 };
+/**
+ * Type function for specifying field types
+ * The parameter is optional and not used - it's just for TypeGraphQL-style ergonomics
+ */
+export type TypeFunction = (type?: unknown) => unknown;
+/**
+ * Options for the @field() decorator
+ */
+export interface FieldOptions {
+    nullable?: boolean;
+    readonly?: boolean;
+}
+/**
+ * Metadata stored for each field
+ */
+export interface FieldMetadata {
+    name: string;
+    typeFunction?: TypeFunction;
+    options: FieldOptions;
+}
 export type TypeGroup = 'String' | 'Number' | 'Boolean' | 'Enum' | 'Union' | 'Intersection' | 'Function' | 'Class' | 'Interface' | 'Type' | 'Array' | 'Object' | 'ReadonlyArray' | 'Other';
 export interface TypeMetadata {
     name: string;

package/dist/promises.js

@@ -33,6 +33,7 @@ class Promises {
 }
 exports.Promises = Promises;
 class PromisesError extends Error {
+    failedReasons;
     constructor(rejectedResults) {
         const reasons = rejectedResults.map((res) => res.reason);
         super(reasons.join('. '));

package/dist/retrier.js

@@ -15,9 +15,9 @@ async function retryIfError(logicToRetry, errorClassThatRetries, logger, maxRetr
     let errorAfterMaxTries;
     for (tryNumber = 1; tryNumber <= maxRetries; tryNumber++) {
         try {
-            logger === null || logger === void 0 ? void 0 : logger.debug(`[retryIfError] Try number ${tryNumber}`);
+            logger?.debug(`[retryIfError] Try number ${tryNumber}`);
             const result = await logicToRetry(tryNumber);
-            logger === null || logger === void 0 ? void 0 : logger.debug(`[retryIfError] Succeeded after ${tryNumber} retries`);
+            logger?.debug(`[retryIfError] Succeeded after ${tryNumber} retries`);
             return result;
         }
         catch (e) {
@@ -30,7 +30,7 @@ async function retryIfError(logicToRetry, errorClassThatRetries, logger, maxRetr
 }
 function checkRetryError(e, errorClassThatRetries, logger) {
     if (!(e instanceof errorClassThatRetries)) {
-        logger === null || logger === void 0 ? void 0 : logger.debug('[checkRetryError] Logic failed with an error that must not be retried. Rethrowing');
+        logger?.debug('[checkRetryError] Logic failed with an error that must not be retried. Rethrowing');
         throw e;
     }
 }

package/dist/searcher.js

@@ -7,6 +7,16 @@ exports.Searcher = void 0;
  * Check the documentation on the individual methods to know more about how to do so.
  */
 class Searcher {
+    objectClass;
+    searcherFunction;
+    finderByKeyFunction;
+    // private offset?: number
+    _limit;
+    _afterCursor;
+    filters = {};
+    _sortByList = {};
+    _paginatedVersion = false;
+    _selectFor;
     /**
      * @param objectClass The class of the object you want to run the search for.
      * @param searcherFunction The function that will receive all the filters and run the actual search
@@ -16,9 +26,6 @@ class Searcher {
         this.objectClass = objectClass;
         this.searcherFunction = searcherFunction;
         this.finderByKeyFunction = finderByKeyFunction;
-        this.filters = {};
-        this._sortByList = {};
-        this._paginatedVersion = false;
     }
     /**
      * Adds a filter for the search. For example: If you want to search for people whose age is greater than 30

package/dist/timestamp-generator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Generates unique, monotonically increasing ISO 8601 timestamps with sub-millisecond precision.
+ *
+ * Format: 2024-01-28T12:34:56.12345678Z where:
+ * - Digits 1-3 (123): actual milliseconds from Date.now()
+ * - Digits 4-7 (4567): monotonic counter (0000-9999)
+ * - Digit 8 (8): random seed for distributed uniqueness (0-9)
+ *
+ * This provides:
+ * - 10,000 unique orderable timestamps per millisecond per instance
+ * - 100,000 total combinations across distributed instances (10,000 counter values × 10 seeds)
+ * - Standard ISO 8601 format parseable by any Date library
+ * - Deterministic ordering via string comparison
+ * - Random component for distributed uniqueness
+ */
+export declare class TimestampGenerator {
+    private lastMs;
+    private counter;
+    private readonly randomSeed;
+    constructor();
+    /**
+     * Generates the next unique timestamp with microsecond precision.
+     *
+     * @returns ISO 8601 timestamp string with 8 fractional digits
+     */
+    next(): string;
+}
+/**
+ * Returns the singleton TimestampGenerator instance.
+ * Creates it if it doesn't exist yet.
+ *
+ * @returns The global TimestampGenerator instance
+ */
+export declare function getTimestampGenerator(): TimestampGenerator;
+/**
+ * Resets the singleton instance. Primarily for testing purposes.
+ */
+export declare function resetTimestampGenerator(): void;

package/dist/timestamp-generator.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampGenerator = void 0;
+exports.getTimestampGenerator = getTimestampGenerator;
+exports.resetTimestampGenerator = resetTimestampGenerator;
+/**
+ * Generates unique, monotonically increasing ISO 8601 timestamps with sub-millisecond precision.
+ *
+ * Format: 2024-01-28T12:34:56.12345678Z where:
+ * - Digits 1-3 (123): actual milliseconds from Date.now()
+ * - Digits 4-7 (4567): monotonic counter (0000-9999)
+ * - Digit 8 (8): random seed for distributed uniqueness (0-9)
+ *
+ * This provides:
+ * - 10,000 unique orderable timestamps per millisecond per instance
+ * - 100,000 total combinations across distributed instances (10,000 counter values × 10 seeds)
+ * - Standard ISO 8601 format parseable by any Date library
+ * - Deterministic ordering via string comparison
+ * - Random component for distributed uniqueness
+ */
+class TimestampGenerator {
+    lastMs = 0;
+    counter = 0;
+    randomSeed;
+    constructor() {
+        // Generate random seed 0-9 for distributed uniqueness
+        this.randomSeed = Math.floor(Math.random() * 10);
+    }
+    /**
+     * Generates the next unique timestamp with microsecond precision.
+     *
+     * @returns ISO 8601 timestamp string with 8 fractional digits
+     */
+    next() {
+        const nowMs = Date.now();
+        // Reset counter only if we've moved forward to a new millisecond
+        // When nowMs <= lastMs (clock skew), continue using lastMs and incrementing counter
+        if (nowMs > this.lastMs) {
+            this.lastMs = nowMs;
+            this.counter = 0;
+        }
+        // If counter exceeds 9999, advance lastMs to maintain monotonicity
+        if (this.counter > 9999) {
+            this.lastMs++;
+            this.counter = 0;
+        }
+        // Format: milliseconds (3 digits) + counter (4 digits) + seed (1 digit)
+        const microPart = String(this.counter).padStart(4, '0') + String(this.randomSeed);
+        this.counter++;
+        // Build ISO 8601 timestamp with microsecond precision
+        // Use lastMs (which may be clamped due to clock skew) instead of nowMs
+        const date = new Date(this.lastMs);
+        const isoString = date.toISOString();
+        // Replace milliseconds with our extended precision
+        // ISO format: 2024-01-28T12:34:56.123Z
+        //                                    ^^^
+        // We extend to: 2024-01-28T12:34:56.12345678Z
+        const withMicros = isoString.slice(0, -1) + microPart + 'Z';
+        return withMicros;
+    }
+}
+exports.TimestampGenerator = TimestampGenerator;
+/**
+ * Global singleton instance of TimestampGenerator.
+ */
+let timestampGeneratorInstance;
+/**
+ * Returns the singleton TimestampGenerator instance.
+ * Creates it if it doesn't exist yet.
+ *
+ * @returns The global TimestampGenerator instance
+ */
+function getTimestampGenerator() {
+    if (!timestampGeneratorInstance) {
+        timestampGeneratorInstance = new TimestampGenerator();
+    }
+    return timestampGeneratorInstance;
+}
+/**
+ * Resets the singleton instance. Primarily for testing purposes.
+ */
+function resetTimestampGenerator() {
+    timestampGeneratorInstance = undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magek/common",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "description": "Contains Magek common helpers used by the core and provider packages",
   "keywords": [
     "framework-common-helpers"
@@ -33,7 +33,7 @@
     "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@magek/eslint-config": "^0.0.6",
+    "@magek/eslint-config": "^0.0.7",
     "@types/chai": "5.2.3",
     "@types/chai-as-promised": "8.0.2",
     "@types/mocha": "10.0.10",

package/dist/field-decorator.d.ts

@@ -1,63 +0,0 @@
-import 'reflect-metadata';
-/**
- * Type function for specifying field types
- * The parameter is optional and not used - it's just for TypeGraphQL-style ergonomics
- */
-export type TypeFunction = (type?: unknown) => unknown;
-/**
- * Options for the @Field() decorator
- */
-export interface FieldOptions {
-    nullable?: boolean;
-    readonly?: boolean;
-}
-/**
- * Metadata stored for each field
- */
-export interface FieldMetadata {
-    name: string;
-    typeFunction?: TypeFunction;
-    options: FieldOptions;
-    designType?: unknown;
-}
-/**
- * Stage 3 decorator context for class fields (TypeScript 5.0+)
- */
-interface Stage3FieldContext {
-    kind: 'field';
-    name: string | symbol;
-    static: boolean;
-    private: boolean;
-    metadata: Record<string | symbol, unknown>;
-    access?: {
-        get: () => unknown;
-        set: (value: unknown) => void;
-    };
-    addInitializer?: (initializer: () => void) => void;
-}
-/**
- * Decorator return type that supports both legacy and Stage 3 formats.
- * This is a function that can be called with either signature.
- */
-type UniversalFieldDecorator = {
-    (target: object, propertyKey: string | symbol): void;
-    (value: undefined, context: Stage3FieldContext): void;
-};
-/**
- * @Field() decorator for explicit type declaration
- *
- * Supports both legacy decorators (experimentalDecorators) and
- * Stage 3 TC39 decorators.
- *
- * Usage:
- *   @Field() - Simple type (inferred from design:type in legacy mode)
- *   @Field(type => String) - Explicit type
- *   @Field(type => [String]) - Array type
- *   @Field({ nullable: true }) - With options
- *   @Field(type => String, { nullable: true }) - Type with options
- */
-export declare function Field(): UniversalFieldDecorator;
-export declare function Field(options: FieldOptions): UniversalFieldDecorator;
-export declare function Field(typeFunction: TypeFunction): UniversalFieldDecorator;
-export declare function Field(typeFunction: TypeFunction, options: FieldOptions): UniversalFieldDecorator;
-export {};

package/dist/field-decorator.js

@@ -1,122 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Field = Field;
-require("reflect-metadata");
-// Symbol for storing fields metadata (for Stage 3 decorators)
-const FIELDS_KEY = Symbol.for('magek:fields');
-/**
- * Type guard to detect Stage 3 decorator context
- */
-function isStage3Context(arg) {
-    return (arg !== null &&
-        typeof arg === 'object' &&
-        'kind' in arg &&
-        arg.kind === 'field' &&
-        'name' in arg &&
-        'metadata' in arg);
-}
-/**
- * Store field metadata on a constructor (works for both legacy and Stage 3)
- */
-function storeFieldMetadata(constructor, fieldMetadata) {
-    // Get existing fields
-    let existingFields = [];
-    // Try Reflect.getMetadata first
-    try {
-        if (typeof Reflect !== 'undefined' && typeof Reflect.getMetadata === 'function') {
-            existingFields = Reflect.getMetadata('magek:fields', constructor) || [];
-        }
-    }
-    catch {
-        // Ignore
-    }
-    // Also check fallback property
-    const ctorWithFields = constructor;
-    if (existingFields.length === 0 && ctorWithFields.__magek_fields__) {
-        existingFields = ctorWithFields.__magek_fields__;
-    }
-    // Add this field (avoid duplicates by name)
-    const filteredFields = existingFields.filter((f) => f.name !== fieldMetadata.name);
-    filteredFields.push(fieldMetadata);
-    // Store using both mechanisms for reliability
-    try {
-        if (typeof Reflect !== 'undefined' && typeof Reflect.defineMetadata === 'function') {
-            Reflect.defineMetadata('magek:fields', filteredFields, constructor);
-        }
-    }
-    catch {
-        // Ignore
-    }
-    // Also store as a fallback property
-    ctorWithFields.__magek_fields__ = filteredFields;
-}
-/**
- * Handle legacy decorator format (experimentalDecorators)
- */
-function handleLegacyDecorator(target, propertyKey, typeFunction, fieldOptions) {
-    // Get design type from TypeScript decorator metadata
-    let designType;
-    try {
-        if (typeof Reflect !== 'undefined' && typeof Reflect.getMetadata === 'function') {
-            designType = Reflect.getMetadata('design:type', target, propertyKey);
-        }
-    }
-    catch {
-        // Ignore - Reflect.getMetadata may fail if called before initialization
-    }
-    const fieldMetadata = {
-        name: propertyKey.toString(),
-        typeFunction,
-        options: fieldOptions,
-        designType,
-    };
-    const constructor = target.constructor;
-    if (constructor) {
-        storeFieldMetadata(constructor, fieldMetadata);
-    }
-}
-/**
- * Handle Stage 3 decorator format (TC39 decorators)
- */
-function handleStage3Decorator(context, typeFunction, fieldOptions) {
-    const fieldMetadata = {
-        name: context.name.toString(),
-        typeFunction,
-        options: fieldOptions,
-        designType: undefined, // Stage 3 doesn't have design:type
-    };
-    // Store in context.metadata for later retrieval by class decorators
-    // Class decorators (like @Command, @Entity, etc.) will transfer this to the class constructor
-    if (!context.metadata[FIELDS_KEY]) {
-        context.metadata[FIELDS_KEY] = [];
-    }
-    const fields = context.metadata[FIELDS_KEY];
-    const filteredFields = fields.filter((f) => f.name !== fieldMetadata.name);
-    filteredFields.push(fieldMetadata);
-    context.metadata[FIELDS_KEY] = filteredFields;
-}
-function Field(typeFunctionOrOptions, options) {
-    // Parse arguments
-    let typeFunction;
-    let fieldOptions = {};
-    if (typeof typeFunctionOrOptions === 'function') {
-        typeFunction = typeFunctionOrOptions;
-        fieldOptions = options || {};
-    }
-    else if (typeFunctionOrOptions) {
-        fieldOptions = typeFunctionOrOptions;
-    }
-    // Return decorator that handles both formats
-    return function fieldDecorator(targetOrValue, propertyKeyOrContext) {
-        // Detect Stage 3 vs Legacy based on the second argument
-        if (isStage3Context(propertyKeyOrContext)) {
-            // Stage 3 decorator
-            handleStage3Decorator(propertyKeyOrContext, typeFunction, fieldOptions);
-        }
-        else if (targetOrValue) {
-            // Legacy decorator
-            handleLegacyDecorator(targetOrValue, propertyKeyOrContext, typeFunction, fieldOptions);
-        }
-        // If targetOrValue is undefined and not Stage 3, silently skip
-    };
-}