@hotmeshio/hotmesh 0.3.5 → 0.3.7

package/build/services/meshflow/search.js

@@ -14,7 +14,7 @@ class Search {
         this.jobId = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
         this.searchSessionId = searchSessionId;
         this.hotMeshClient = hotMeshClient;
-        this.store = hotMeshClient.engine.store;
+        this.search = hotMeshClient.engine.search;
     }
     safeKey(key) {
         if (key.startsWith('"')) {
@@ -24,7 +24,7 @@ class Search {
     }
     static async configureSearchIndex(hotMeshClient, search) {
         if (search?.schema) {
-            const store = hotMeshClient.engine.store;
+            const searchService = hotMeshClient.engine.search;
             const schema = [];
             for (const [key, value] of Object.entries(search.schema)) {
                 if (value.indexed !== false) {
@@ -50,7 +50,7 @@ class Search {
                 };
                 const hotMeshPrefix = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
                 const prefixes = search.prefix.map((prefix) => `${hotMeshPrefix}${prefix}`);
-                await store.exec('FT.CREATE', `${search.index}`, 'ON', 'HASH', 'PREFIX', prefixes.length.toString(), ...prefixes, 'SCHEMA', ...schema);
+                await searchService.createSearchIndex(`${search.index}`, prefixes, schema);
             }
             catch (error) {
                 hotMeshClient.engine.logger.info('meshflow-client-search-err', {
@@ -61,9 +61,8 @@ class Search {
     }
     static async listSearchIndexes(hotMeshClient) {
         try {
-            const store = hotMeshClient.engine.store;
-            const searchIndexes = await store.exec('FT._LIST');
-            return searchIndexes;
+            const searchService = hotMeshClient.engine.search;
+            return await searchService.listSearchIndexes();
         }
         catch (error) {
             hotMeshClient.engine.logger.info('meshflow-client-search-list-err', {
@@ -79,32 +78,42 @@ class Search {
         const ssGuid = this.getSearchSessionGuid();
         const store = storage_1.asyncLocalStorage.getStore();
         const replay = store?.get('replay') ?? {};
-        const safeArgs = [];
-        for (let i = 0; i < args.length; i += 2) {
-            const keyName = args[i];
-            delete this.cachedFields[keyName];
-            const key = this.safeKey(keyName);
-            const value = args[i + 1].toString();
-            safeArgs.push(key, value);
-        }
         if (ssGuid in replay) {
             return Number(replay[ssGuid]);
         }
-        const fieldCount = await this.store.exec('HSET', this.jobId, ...safeArgs);
-        this.store.exec('HSET', this.jobId, ssGuid, fieldCount.toString());
-        return Number(fieldCount);
+        const fields = {};
+        if (typeof args[0] === 'object') {
+            for (const [key, value] of Object.entries(args[0])) {
+                delete this.cachedFields[key];
+                fields[this.safeKey(key)] = value.toString();
+            }
+        }
+        else {
+            for (let i = 0; i < args.length; i += 2) {
+                const keyName = args[i];
+                delete this.cachedFields[keyName];
+                const key = this.safeKey(keyName);
+                const value = args[i + 1].toString();
+                fields[key] = value;
+            }
+        }
+        const fieldCount = await this.search.setFields(this.jobId, fields);
+        await this.search.setFields(this.jobId, { [ssGuid]: fieldCount.toString() });
+        return fieldCount;
     }
-    async get(key) {
+    async get(id) {
         try {
-            if (key in this.cachedFields) {
-                return this.cachedFields[key];
+            if (id in this.cachedFields) {
+                return this.cachedFields[id];
             }
-            const value = (await this.store.exec('HGET', this.jobId, this.safeKey(key)));
-            this.cachedFields[key] = value;
+            const value = await this.search.getField(this.jobId, this.safeKey(id));
+            this.cachedFields[id] = value;
             return value;
         }
         catch (error) {
-            this.hotMeshClient.logger.error('meshflow-search-get-error', { ...error });
+            this.hotMeshClient.logger.error('meshflow-search-get-error', {
+                ...error,
+            });
             return '';
         }
     }
@@ -125,7 +134,7 @@ class Search {
             if (isCached) {
                 return values;
             }
-            const returnValues = (await this.store.exec('HMGET', this.jobId, ...safeArgs));
+            const returnValues = await this.search.getFields(this.jobId, safeArgs);
             returnValues.forEach((value, index) => {
                 if (value !== null) {
                     this.cachedFields[args[index]] = value;
@@ -153,11 +162,9 @@ class Search {
         if (ssGuid in replay) {
             return Number(replay[ssGuid]);
         }
-        const response = await this.store.exec('HDEL', this.jobId, ...safeArgs);
-        const formattedResponse = isNaN(response)
-            ? 0
-            : Number(response);
-        this.store.exec('HSET', this.jobId, ssGuid, formattedResponse.toString());
+        const response = await this.search.deleteFields(this.jobId, safeArgs);
+        const formattedResponse = isNaN(response) ? 0 : Number(response);
+        await this.search.setFields(this.jobId, { [ssGuid]: formattedResponse.toString() });
         return formattedResponse;
     }
     async incr(key, val) {
@@ -168,9 +175,9 @@ class Search {
         if (ssGuid in replay) {
             return Number(replay[ssGuid]);
         }
-        const num = (await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), val.toString()));
-        this.store.exec('HSET', this.jobId, ssGuid, num.toString());
-        return Number(num);
+        const num = await this.search.incrementFieldByFloat(this.jobId, this.safeKey(key), val);
+        await this.search.setFields(this.jobId, { [ssGuid]: num.toString() });
+        return num;
     }
     async mult(key, val) {
         delete this.cachedFields[key];
@@ -180,12 +187,17 @@ class Search {
         if (ssGuid in replay) {
             return Math.exp(Number(replay[ssGuid]));
         }
-        const ssGuidValue = Number((await this.store.exec('HINCRBYFLOAT', this.jobId, ssGuid, '1')));
+        const ssGuidValue = await this.search.incrementFieldByFloat(this.jobId, ssGuid, 1);
         if (ssGuidValue === 1) {
             const log = Math.log(val);
-            const logTotal = (await this.store.exec('HINCRBYFLOAT', this.jobId, this.safeKey(key), log.toString()));
-            this.store.exec('HSET', this.jobId, ssGuid, logTotal.toString());
-            return Math.exp(Number(logTotal));
+            const logTotal = await this.search.incrementFieldByFloat(this.jobId, this.safeKey(key), log);
+            await this.search.setFields(this.jobId, { [ssGuid]: logTotal.toString() });
+            return Math.exp(logTotal);
+        }
+        else {
+            const logTotalStr = await this.search.getField(this.jobId, ssGuid);
+            const logTotal = Number(logTotalStr);
+            return Math.exp(logTotal);
         }
     }
 }

package/build/services/meshflow/worker.js

@@ -237,7 +237,7 @@ class WorkerService {
                     isProcessing = true;
                     const workflowInput = data.data;
                     const execIndex = counter.counter - interruptionRegistry.length + 1;
-                    const { workflowId, workflowTopic, workflowDimension, originJobId, expire } = workflowInput;
+                    const { workflowId, workflowTopic, workflowDimension, originJobId, expire, } = workflowInput;
                     const collatorFlowId = `${(0, utils_1.guid)()}$C`;
                     return {
                         status: stream_1.StreamStatus.SUCCESS,

package/build/services/meshflow/workflow.d.ts

@@ -10,6 +10,7 @@ export declare class WorkflowService {
     static getContext(): WorkflowContext;
     static getHotMesh(): Promise<HotMesh>;
     static execChild<T>(options: WorkflowOptions): Promise<T>;
+    static executeChild: typeof WorkflowService.execChild;
     static getChildInterruptPayload(context: WorkflowContext, options: WorkflowOptions, execIndex: number): MeshFlowChildErrorType;
     static startChild(options: WorkflowOptions): Promise<string>;
     static proxyActivities<ACT>(options?: ActivityConfig): ProxyType<ACT>;
@@ -19,7 +20,6 @@ export declare class WorkflowService {
     static random(): number;
     static signal(signalId: string, data: Record<any, any>): Promise<string>;
     static hook(options: HookOptions): Promise<string>;
-    static once<T>(fn: (...args: any[]) => Promise<T>, ...args: any[]): Promise<T>;
     static interrupt(jobId: string, options?: JobInterruptOptions): Promise<string | void>;
     static all<T>(...promises: Promise<T>[]): Promise<T[]>;
     static sleepFor(duration: string): Promise<number>;

package/build/services/meshflow/workflow.js

@@ -38,7 +38,8 @@ class WorkflowService {
             jobId: workflowId,
         };
         const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        const guidValue = Number((await hotMeshClient.engine.store.exec('HINCRBYFLOAT', workflowGuid, sessionId, '1')));
+        const searchClient = hotMeshClient.engine.search;
+        const guidValue = await searchClient.incrementFieldByFloat(workflowGuid, sessionId, 1);
         return guidValue === 1;
     }
     static getContext() {
@@ -116,7 +117,7 @@ class WorkflowService {
                 }
                 return result.$error;
             }
-            else {
+            else if (!result?.$error) {
                 return result.data;
             }
         }
@@ -135,7 +136,7 @@ class WorkflowService {
             childJobId = options.workflowId;
         }
         else if (options.entity) {
-            childJobId = `${options.entity}-${workflowId.substring(0, 7)}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
+            childJobId = `${options.entity}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
         }
         else {
             childJobId = `-${options.workflowName}-${(0, utils_1.guid)()}-${workflowDimension}-${execIndex}`;
@@ -299,33 +300,6 @@ class WorkflowService {
             return await hotMeshClient.hook(`${namespace}.flow.signal`, payload, stream_1.StreamStatus.PENDING, 202);
         }
     }
-    static async once(fn, ...args) {
-        const { COUNTER, connection, namespace, workflowId, workflowTopic, workflowDimension, replay, } = WorkflowService.getContext();
-        const execIndex = COUNTER.counter = COUNTER.counter + 1;
-        const sessionId = `-once${workflowDimension}-${execIndex}-`;
-        if (sessionId in replay) {
-            return serializer_1.SerializerService.fromString(replay[sessionId]).data;
-        }
-        const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
-            connection,
-            namespace,
-        });
-        const keyParams = {
-            appId: hotMeshClient.appId,
-            jobId: workflowId,
-        };
-        const workflowGuid = key_1.KeyService.mintKey(hotMeshClient.namespace, key_1.KeyType.JOB_STATE, keyParams);
-        const t1 = new Date();
-        const response = await fn(...args);
-        const t2 = new Date();
-        const payload = {
-            data: response,
-            ac: (0, utils_1.formatISODate)(t1),
-            au: (0, utils_1.formatISODate)(t2),
-        };
-        await hotMeshClient.engine.store.exec('HSET', workflowGuid, sessionId, serializer_1.SerializerService.toString(payload));
-        return response;
-    }
     static async interrupt(jobId, options = {}) {
         const { workflowTopic, connection, namespace } = WorkflowService.getContext();
         const hotMeshClient = await worker_1.WorkerService.getHotMesh(workflowTopic, {
@@ -385,4 +359,5 @@ class WorkflowService {
         throw new errors_1.MeshFlowWaitForError(interruptionMessage);
     }
 }
+WorkflowService.executeChild = WorkflowService.execChild;
 exports.WorkflowService = WorkflowService;

package/build/services/meshos/index.d.ts

@@ -0,0 +1,81 @@
+import { MeshData } from '../meshdata/index';
+import * as Types from '../../types';
+declare abstract class MeshOS {
+    meshData: MeshData;
+    connected: boolean;
+    namespace: string;
+    namespaceType: string;
+    static databases: Record<string, Types.DB>;
+    static namespaces: Types.Namespaces;
+    static entities: Record<string, Types.Entity>;
+    static schemas: Record<string, Types.WorkflowSearchSchema>;
+    static profiles: Types.Profiles;
+    static classes: Record<string, typeof MeshOS>;
+    static logger: Types.ILogger;
+    constructor(namespace: string, namespaceType: string, config: Types.DBConfig);
+    protected abstract getEntity(): string;
+    abstract getSearchOptions(): Types.WorkflowSearchOptions;
+    protected abstract getTaskQueue(): string;
+    private initializeMeshData;
+    protected defaultTargetFn(): Promise<string>;
+    getNamespace(): string;
+    getRedisUrl: (config: Types.DBConfig) => {
+        url: string;
+    };
+    connect(): Promise<void>;
+    index(): Promise<void>;
+    static shutdown(): Promise<void>;
+    getIndexName(): string;
+    create(body: Record<string, any>): Promise<Types.StringStringType>;
+    retrieve(id: string, sparse?: boolean): Promise<Types.StringStringType>;
+    update(id: string, body: Record<string, any>): Promise<Types.StringStringType>;
+    delete(id: string): Promise<boolean>;
+    find(query?: {
+        field: string;
+        is: '=' | '[]' | '>=' | '<=';
+        value: string;
+    }[], start?: number, size?: number): Promise<{
+        count: number;
+        query: string;
+        data: Types.StringStringType[];
+    }>;
+    count(query: {
+        field: string;
+        is: '=' | '[]' | '>=' | '<=';
+        value: string;
+    }[]): Promise<number>;
+    aggregate(filter?: {
+        field: string;
+        is: '=' | '[]' | '>=' | '<=';
+        value: string;
+    }[], apply?: {
+        expression: string;
+        as: string;
+    }[], rows?: string[], columns?: string[], reduce?: {
+        operation: string;
+        as: string;
+        property?: string;
+    }[], sort?: {
+        field: string;
+        order: 'ASC' | 'DESC';
+    }[], start?: number, size?: number): Promise<{
+        count: number;
+        query: string;
+        data: Types.StringStringType[];
+    }>;
+    private buildAggregateCommand;
+    private buildFilterCommand;
+    init(search?: boolean): Promise<void>;
+    static registerDatabase(id: string, config: Types.DB): void;
+    static registerNamespace(id: string, config: Types.Namespace): void;
+    static registerEntity(id: string, config: Types.Entity): void;
+    static registerSchema(id: string, schema: Types.WorkflowSearchSchema): void;
+    static registerProfile(id: string, config: Types.Profile): void;
+    static registerClass(id: string, entityClass: typeof MeshOS): void;
+    static init(p?: Types.Profiles): Promise<void>;
+    static findEntity(database: string, namespace: string, entity: string): Types.EntityInstanceTypes | undefined;
+    static findSchemas(database: string, ns: string): Record<string, Types.WorkflowSearchSchema>;
+    static toJSON(p?: Types.Profiles): any;
+    workflow: {};
+}
+export { MeshOS };

package/build/services/meshos/index.js

@@ -0,0 +1,339 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MeshOS = void 0;
+const Redis = __importStar(require("redis"));
+const index_1 = require("../meshdata/index");
+const utils_1 = require("../../modules/utils");
+const logger_1 = require("../logger");
+class MeshOS {
+    constructor(namespace, namespaceType, config) {
+        this.connected = false;
+        this.getRedisUrl = (config) => {
+            return {
+                url: `redis${config.REDIS_USE_TLS ? 's' : ''}://${config.REDIS_USERNAME ?? ''}:${config.REDIS_PASSWORD}@${config.REDIS_HOST}:${config.REDIS_PORT}`,
+            };
+        };
+        this.workflow = {};
+        this.namespace = namespace;
+        this.namespaceType = namespaceType;
+        this.meshData = this.initializeMeshData(config);
+    }
+    initializeMeshData(dbConfig) {
+        return new index_1.MeshData(Redis, this.getRedisUrl(dbConfig), this.getSearchOptions());
+    }
+    async defaultTargetFn() {
+        return 'OK';
+    }
+    getNamespace() {
+        return this.namespace;
+    }
+    async connect() {
+        this.connected = await this.meshData.connect({
+            entity: this.getEntity(),
+            target: this.defaultTargetFn,
+            options: {
+                namespace: this.getNamespace(),
+                taskQueue: this.getTaskQueue(),
+            },
+        });
+    }
+    async index() {
+        await this.meshData.createSearchIndex(this.getEntity(), { namespace: this.getNamespace() }, this.getSearchOptions());
+    }
+    static async shutdown() {
+        await index_1.MeshData.shutdown();
+    }
+    getIndexName() {
+        return this.getSearchOptions().index;
+    }
+    async create(body) {
+        const id = body.id || (0, utils_1.guid)();
+        await this.meshData.set(this.getEntity(), id, {
+            search: { data: body },
+            namespace: this.getNamespace(),
+        });
+        return this.retrieve(id);
+    }
+    async retrieve(id, sparse = false) {
+        const opts = this.getSearchOptions();
+        const fields = sparse ? ['id'] : Object.keys(opts?.schema || {});
+        const result = await this.meshData.get(this.getEntity(), id, {
+            fields,
+            namespace: this.getNamespace(),
+        });
+        if (!result?.id)
+            throw new Error(`${this.getEntity()} not found`);
+        return result;
+    }
+    async update(id, body) {
+        await this.retrieve(id);
+        await this.meshData.set(this.getEntity(), id, {
+            search: { data: body },
+            namespace: this.getNamespace(),
+        });
+        return this.retrieve(id);
+    }
+    async delete(id) {
+        await this.retrieve(id);
+        await this.meshData.flush(this.getEntity(), id, this.getNamespace());
+        return true;
+    }
+    async find(query = [], start = 0, size = 100) {
+        const opts = this.getSearchOptions();
+        return this.meshData.findWhere(this.getEntity(), {
+            query,
+            return: Object.keys(opts?.schema || {}),
+            limit: { start, size },
+            options: { namespace: this.getNamespace() },
+        });
+    }
+    async count(query) {
+        return this.meshData.findWhere(this.getEntity(), {
+            query,
+            count: true,
+            options: { namespace: this.getNamespace() },
+        });
+    }
+    async aggregate(filter = [], apply = [], rows = [], columns = [], reduce = [], sort = [], start = 0, size = 100) {
+        const command = this.buildAggregateCommand(filter, apply, rows, columns, reduce, sort);
+        try {
+            const results = await this.meshData.find(this.getEntity(), {
+                index: this.getIndexName(),
+                namespace: this.getNamespace(),
+                taskQueue: this.getTaskQueue(),
+                search: this.getSearchOptions(),
+            }, ...command);
+            return {
+                count: results[0],
+                query: command.join(' '),
+                data: (0, utils_1.arrayToHash)(results),
+            };
+        }
+        catch (e) {
+            throw e;
+        }
+    }
+    buildAggregateCommand(filter, apply, rows, columns, reduce, sort) {
+        const command = ['FT.AGGREGATE', this.getIndexName() || 'default'];
+        const opts = this.getSearchOptions();
+        command.push(this.buildFilterCommand(filter));
+        apply.forEach((a) => command.push('APPLY', a.expression, 'AS', a.as));
+        const groupBy = rows.concat(columns);
+        if (groupBy.length > 0) {
+            command.push('GROUPBY', `${groupBy.length}`, ...groupBy.map((g) => opts?.schema?.[g] ? `@_${g}` : `@${g}`));
+        }
+        reduce.forEach((r) => {
+            const op = r.operation.toUpperCase();
+            if (op === 'COUNT') {
+                command.push('REDUCE', op, '0', 'AS', r.as ?? 'count');
+            }
+            else if ([
+                'COUNT_DISTINCT',
+                'COUNT_DISTINCTISH',
+                'SUM',
+                'AVG',
+                'MIN',
+                'MAX',
+                'STDDEV',
+                'TOLIST',
+            ].includes(op)) {
+                const property = r.property
+                    ? opts?.schema?.[r.property]
+                        ? `@_${r.property}`
+                        : `@${r.property}`
+                    : '';
+                command.push('REDUCE', op, '1', property, 'AS', r.as ?? `${r.operation}_${r.property}`);
+            }
+        });
+        if (sort.length > 0) {
+            command.push('SORTBY', `${2 * sort.length}`, ...sort.flatMap((s) => [
+                opts?.schema?.[s.field] ? `@_${s.field}` : `@${s.field}`,
+                s.order.toUpperCase() || 'DESC',
+            ]));
+        }
+        return command;
+    }
+    buildFilterCommand(filter) {
+        if (filter.length === 0)
+            return '*';
+        const opts = this.getSearchOptions();
+        return filter
+            .map((q) => {
+            const type = opts?.schema?.[q.field]?.type ?? 'TEXT';
+            switch (type) {
+                case 'TAG':
+                    return `@_${q.field}:{${q.value}}`;
+                case 'TEXT':
+                    return `@_${q.field}:${q.value}`;
+                case 'NUMERIC':
+                    return `@_${q.field}:[${q.value}]`;
+            }
+        })
+            .join(' ');
+    }
+    async init(search = true) {
+        await this.connect();
+        if (search) {
+            await this.index();
+        }
+    }
+    static registerDatabase(id, config) {
+        MeshOS.databases[id] = config;
+    }
+    static registerNamespace(id, config) {
+        MeshOS.namespaces[id] = config;
+    }
+    static registerEntity(id, config) {
+        MeshOS.entities[id] = config;
+    }
+    static registerSchema(id, schema) {
+        MeshOS.schemas[id] = schema;
+    }
+    static registerProfile(id, config) {
+        MeshOS.profiles[id] = config;
+    }
+    static registerClass(id, entityClass) {
+        MeshOS.classes[id] = entityClass;
+    }
+    static async init(p = MeshOS.profiles) {
+        for (const key in p) {
+            const profile = p[key];
+            if (profile.db.config.REDIS_HOST) {
+                this.logger.info(`meshos-initializing`, {
+                    db: profile.db.name,
+                    key,
+                });
+                profile.instances = {};
+                for (const ns in profile.namespaces) {
+                    const namespace = profile.namespaces[ns];
+                    this.logger.info(`meshos-initializing-namespace`, {
+                        namespace: ns,
+                        label: namespace.label,
+                    });
+                    let pinstances = profile.instances[ns];
+                    if (!pinstances) {
+                        pinstances = {};
+                        profile.instances[ns] = pinstances;
+                    }
+                    for (const entity of namespace.entities) {
+                        this.logger.info(`meshos-initializing-entity`, {
+                            entity: entity.name,
+                            label: entity.label,
+                        });
+                        const instance = pinstances[entity.name] = new entity.class(ns, namespace.type, profile.db.config);
+                        await instance.init(profile.db.search);
+                    }
+                }
+            }
+        }
+    }
+    static findEntity(database, namespace, entity) {
+        if (!database ||
+            !MeshOS.profiles[database] ||
+            !MeshOS.profiles[database]?.db?.config?.REDIS_HOST) {
+            const activeProfiles = Object.keys(MeshOS.profiles).filter((key) => MeshOS.profiles[key]?.db?.config?.REDIS_HOST);
+            throw new Error(`The database query parameter [${database}] was not found. Use one of: ${activeProfiles.join(', ')}`);
+        }
+        if (!namespace || !MeshOS.profiles[database]?.instances?.[namespace]) {
+            const activeNamespaces = Object.keys(MeshOS.profiles[database]?.instances ?? {});
+            throw new Error(`The namespace query parameter [${namespace}] was not found. Use one of: ${activeNamespaces.join(', ')}`);
+        }
+        const entities = MeshOS.profiles[database]?.instances?.[namespace] ?? {};
+        if (!entity || entity?.startsWith('-') || entity === '*') {
+            entity = Object.keys(entities)[0];
+        }
+        else if (entity?.endsWith('*')) {
+            entity = entity.slice(0, -1);
+        }
+        const target = MeshOS.profiles[database]?.instances?.[namespace]?.[entity];
+        if (!target) {
+            this.logger.error(`meshos-entity-not-found`, {
+                database,
+                namespace,
+                entity,
+            });
+            entity = Object.keys(entities)[0];
+            return MeshOS.profiles[database]?.instances?.[namespace]?.[entity];
+        }
+        return target;
+    }
+    static findSchemas(database, ns) {
+        if (!database ||
+            !MeshOS.profiles[database] ||
+            !MeshOS.profiles[database]?.db?.config?.REDIS_HOST) {
+            const activeProfiles = Object.keys(MeshOS.profiles).filter((key) => MeshOS.profiles[key]?.db?.config?.REDIS_HOST);
+            throw new Error(`The database query parameter [${database}] was not found. Use one of: ${activeProfiles.join(', ')}`);
+        }
+        const profile = MeshOS.profiles[database];
+        const namespacedInstance = profile.instances[ns];
+        const schemas = {};
+        for (const entityName in namespacedInstance) {
+            const entityInstance = namespacedInstance[entityName];
+            const opts = entityInstance.getSearchOptions();
+            schemas[opts.index ?? entityName] = opts.schema;
+        }
+        return schemas;
+    }
+    static toJSON(p = MeshOS.profiles) {
+        const result = {};
+        for (const key in p) {
+            const profile = p[key];
+            if (!profile.db.config.REDIS_HOST) {
+                continue;
+            }
+            else {
+                result[key] = {
+                    db: { ...profile.db, config: undefined },
+                    namespaces: {},
+                };
+            }
+            for (const ns in profile.namespaces) {
+                const namespace = profile.namespaces[ns];
+                result[key].namespaces[ns] = {
+                    name: namespace.name,
+                    label: namespace.label,
+                    entities: [],
+                };
+                for (const entity of namespace.entities) {
+                    result[key].namespaces[ns].entities.push({
+                        name: entity.name,
+                        label: entity.label,
+                        schema: entity.schema,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+}
+exports.MeshOS = MeshOS;
+MeshOS.databases = {};
+MeshOS.namespaces = {};
+MeshOS.entities = {};
+MeshOS.schemas = {};
+MeshOS.profiles = {};
+MeshOS.classes = {};
+MeshOS.logger = new logger_1.LoggerService('hotmesh', 'meshos');