@hotmeshio/hotmesh 0.5.2 → 0.5.4

package/build/services/meshos/index.js

@@ -1,547 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MeshOS = void 0;
-const index_1 = require("../meshdata/index");
-const utils_1 = require("../../modules/utils");
-const logger_1 = require("../logger");
-/**
- * MeshOS is an abstract base class for schema-driven entity management within the Mesh network.
- * It provides a foundation for defining custom entities.
- * By subclassing MeshOS, you can create entities with specific schemas and behaviors, enabling
- * structured data storage, retrieval, and transactional workflows.
- *
- * ### Subclassing MeshOS
- *
- * Standard CRUD methods are included and use your provided schema to
- * fields to return in the response: create, retrieve, update, delete.
- *
- * Search methods are included and use your provided schema to
- * fields to return in the response: count, find, aggregate.
- *
- * Implement other methods as needed for the entity's
- * functionality; For example, subclass/override methods like `create`
- * to also spawn a transactional workflow
- *
- * @example
- * ```typescript
- * import { MeshOS } from '@hotmeshio/hotmesh';
- * import { Types } from '@hotmeshio/hotmesh';
- * import { schema } from './schema'; // Import your schema
- * import * as workflows from './workflows';
- *
- * class Widget extends MeshOS {
- *
- *   //Subclass the `connect` method to connect workers and
- *   // hooks (optional) when the container starts
- *   async connect() {
- *     await this.meshData.connect({
- *       entity: this.getEntity(),
- *       //the `target widget workflow` runs as a transaction
- *       target: function() {
- *         return { hello: 'world' };
- *       },
- *       options: {
- *         namespace: this.getNamespace(),
- *         taskQueue: this.getTaskQueue(),
- *       },
- *     });
- *   }
- *
- *   // subclass the `create` method to start a transactional
- *   // workflow; use the options/search field to set default
- *   // record data `{ ...input}` and invoke the `target widget workflow`
- *   async create(input: Types.StringAnyType): Promise<Types.StringStringType> {
- *     return await this.meshData.exec<Types.StringStringType>({
- *       entity: this.getEntity(),
- *       args: [{ ...input }],
- *       options: {
- *         id: input.id,
- *         ttl: '6 months',
- *         taskQueue: this.getTaskQueue(),
- *         namespace: this.getNamespace(),
- *         search: { data: { ...input }},
- *        },
- *     });
- *   }
- * }
- * ```
- *
- * ### Defining the Schema
- *
- * The schema defines the data model for your entity and is used for indexing and searching within the mesh network.
- * Each field in the schema specifies the data type, whether it's required, and other indexing options.
- *
- * Here's an example of a schema (`schema.ts`):
- *
- * ```typescript
- * import { Types } from '@hotmeshio/hotmesh';
- *
- * export const schema: Types.WorkflowSearchSchema = {
- *   /**
- *    * Unique identifier for the widget, including the entity prefix.
- *    *\/
- *   id: {
- *     type: 'TAG',
- *     primitive: 'string',
- *     required: true,
- *     examples: ['H56789'],
- *   },
- *   /**
- *    * entity type
- *    *\/
- *   $entity: {
- *     type: 'TAG',
- *     primitive: 'string',
- *     required: true,
- *     examples: ['widget'],
- *   },
- *   /**
- *    * Field indicating whether the widget is active ('y') or pruned ('n').
- *    *\/
- *   active: {
- *     type: 'TAG',
- *     primitive: 'string',
- *     required: true,
- *     examples: ['y', 'n'],
- *   },
- *   // ... other fields as needed
- * };
- * ```
- *
- * In your entity class (`Widget`), you use this schema in the
- * `getSearchOptions` method to define how your entity's data
- * is indexed and searched.
- */
-class MeshOS {
-    /**
-     * Instances of MeshOS are typically initialized as a set, using a manifest.json
-     * file that describes statically the fully set names, passwords, entities, etc.
-     * The static init method is invoked to start this process (typically at server
-     * startup).
-     */
-    constructor(providerConfig, namespace, entity, taskQueue, schema) {
-        this.connected = false;
-        this.workflow = {};
-        this.namespace = namespace; // e.g., 'sandbox', 'default', 'production'
-        this.entity = entity;
-        this.taskQueue = taskQueue;
-        this.schema = schema;
-        this.meshData = this.initializeMeshData(providerConfig);
-    }
-    /**
-     * Return entity (e.g, book, library, user)
-     */
-    getEntity() {
-        return this.entity;
-    }
-    /**
-     * Get Search options (initializes the search index, specific to the backend provider)
-     */
-    getSearchOptions() {
-        return {
-            index: `${this.getNamespace()}-${this.getEntity()}`,
-            prefix: [this.getEntity()],
-            schema: this.getSchema(),
-        };
-    }
-    /**
-     * Speficy a more-specific task queue than the default queue (v1, v1priority, v2, acmecorp, etc)
-     */
-    getTaskQueue() {
-        return this.taskQueue;
-    }
-    /**
-     * Initialize MeshData instance (this backs/supports the class
-     * --the true provider of functionality)
-     */
-    initializeMeshData(providerConfig) {
-        return new index_1.MeshData(providerConfig, this.getSearchOptions());
-    }
-    /**
-     * Default target function
-     */
-    async defaultTargetFn() {
-        return 'OK';
-    }
-    /**
-     * Get namespace
-     */
-    getNamespace() {
-        return this.namespace;
-    }
-    /**
-     * Get schema
-     */
-    getSchema() {
-        return this.schema;
-    }
-    /**
-     * Connect to the database
-     */
-    async connect() {
-        this.connected = await this.meshData.connect({
-            entity: this.getEntity(),
-            target: this.defaultTargetFn,
-            options: {
-                namespace: this.getNamespace(),
-                taskQueue: this.getTaskQueue(),
-            },
-        });
-    }
-    /**
-     * Create the search index
-     */
-    async index() {
-        await this.meshData.createSearchIndex(this.getEntity(), { namespace: this.getNamespace() }, this.getSearchOptions());
-    }
-    // On-container shutdown commands
-    /**
-     * Shutdown all connections
-     */
-    static async shutdown() {
-        await index_1.MeshData.shutdown();
-    }
-    /**
-     * Get index name
-     */
-    getIndexName() {
-        return this.getSearchOptions().index;
-    }
-    /**
-     * Create the data record
-     * NOTE: subclasses should override this method (or create
-     * an alternate method) for invoking a workflow when
-     * creating the record.
-     */
-    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);
-    }
-    /**
-     * Retrieve the record data
-     */
-    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;
-    }
-    /**
-     * Update the record data
-     */
-    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);
-    }
-    /**
-     * Delete the record/workflow
-     */
-    async delete(id) {
-        await this.retrieve(id);
-        await this.meshData.flush(this.getEntity(), id, this.getNamespace());
-        return true;
-    }
-    /**
-     * Find matching records
-     */
-    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() },
-        });
-    }
-    /**
-     * Count matching entities
-     */
-    async count(query) {
-        return this.meshData.findWhere(this.getEntity(), {
-            query,
-            count: true,
-            options: { namespace: this.getNamespace() },
-        });
-    }
-    /**
-     * Aggregate matching entities
-     */
-    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;
-        }
-    }
-    /**
-     * Build aggregate command
-     */
-    buildAggregateCommand(filter, apply, rows, columns, reduce, sort) {
-        const command = ['FT.AGGREGATE', this.getIndexName() || 'default'];
-        const opts = this.getSearchOptions();
-        // Add filter
-        command.push(this.buildFilterCommand(filter));
-        // Add apply
-        apply.forEach((a) => command.push('APPLY', a.expression, 'AS', a.as));
-        // Add groupBy
-        const groupBy = rows.concat(columns);
-        if (groupBy.length > 0) {
-            command.push('GROUPBY', `${groupBy.length}`, ...groupBy.map((g) => opts?.schema?.[g] ? `@_${g}` : `@${g}`));
-        }
-        // Add reduce
-        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}`);
-            }
-        });
-        // Add sort
-        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;
-    }
-    /**
-     * Build filter 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(' ');
-    }
-    /**
-     * Instance initializer
-     */
-    async init(search = true) {
-        await this.connect();
-        if (search) {
-            await this.index();
-        }
-    }
-    // Static registration methods
-    /**
-     * Register a database
-     */
-    static registerDatabase(id, config) {
-        MeshOS.databases[id] = config;
-    }
-    /**
-     * Register a namespace
-     */
-    static registerNamespace(id, config) {
-        MeshOS.namespaces[id] = config;
-    }
-    /**
-     * Register an entity
-     */
-    static registerEntity(id, config) {
-        MeshOS.entities[id] = config;
-    }
-    /**
-     * Register a schema
-     */
-    static registerSchema(id, schema) {
-        MeshOS.schemas[id] = schema;
-    }
-    /**
-     * Register a profile
-     */
-    static registerProfile(id, config) {
-        MeshOS.profiles[id] = config;
-    }
-    /**
-     * Register a class
-     */
-    static registerClass(id, entityClass) {
-        MeshOS.classes[id] = entityClass;
-    }
-    /**
-     * Initialize profiles
-     */
-    static async init(p = MeshOS.profiles) {
-        for (const key in p) {
-            const profile = p[key];
-            if (profile.db?.connection) {
-                MeshOS.logger.info(`meshos-initializing`, {
-                    db: profile.db.name,
-                    key,
-                });
-                profile.instances = {};
-                for (const ns in profile.namespaces) {
-                    const namespace = profile.namespaces[ns];
-                    MeshOS.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) {
-                        MeshOS.logger.info(`meshos-initializing-entity`, {
-                            entity: entity.name,
-                            label: entity.label,
-                        });
-                        const instance = pinstances[entity.name] = new entity.class(profile.db.connection, ns, entity.name, entity.taskQueue, entity.schema);
-                        await instance.init(profile.db.search);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Find entity instance
-     */
-    static findEntity(database, namespace, entity) {
-        if (!database || !MeshOS.profiles[database]) {
-            const activeProfiles = Object.keys(MeshOS.profiles).filter((key) => MeshOS.profiles[key]?.db);
-            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) {
-            const fallback = Object.keys(entities)[0];
-            MeshOS.logger.error(`meshos-entity-not-found`, {
-                database,
-                namespace,
-                entity,
-                fallback,
-            });
-            return MeshOS.profiles[database]?.instances?.[namespace]?.[fallback];
-        }
-        return target;
-    }
-    /**
-     * Find schemas
-     */
-    static findSchemas(database, ns) {
-        if (!database || !MeshOS.profiles[database]) {
-            const activeProfiles = Object.keys(MeshOS.profiles).filter((key) => MeshOS.profiles[key]?.db);
-            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;
-    }
-    /**
-     * Serialize profiles to JSON
-     */
-    static toJSON(p = MeshOS.profiles) {
-        const result = {};
-        for (const key in p) {
-            const profile = p[key];
-            if (!profile.db) {
-                continue;
-            }
-            else {
-                // Remove the sensitive `connection` field if present
-                const { connection, ...dbWithoutConnection } = profile.db;
-                result[key] = {
-                    db: { ...dbWithoutConnection },
-                    namespaces: {},
-                };
-            }
-            for (const ns in profile.namespaces) {
-                const namespace = profile.namespaces[ns];
-                result[key].namespaces[ns] = {
-                    name: namespace.name,
-                    label: namespace.label,
-                    module: namespace.module,
-                    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;
-// Static properties
-MeshOS.databases = {};
-MeshOS.namespaces = {};
-MeshOS.entities = {};
-MeshOS.schemas = {};
-MeshOS.profiles = {};
-MeshOS.classes = {};
-MeshOS.logger = new logger_1.LoggerService('hotmesh', 'meshos');

package/build/types/manifest.d.ts

@@ -1,52 +0,0 @@
-import { MeshOS } from '../services/meshos';
-import { WorkflowSearchSchema } from './memflow';
-import { ProviderConfig, ProvidersConfig } from './provider';
-export type DB = {
-    name: string;
-    label: string;
-    search: boolean;
-    connection: ProviderConfig | ProvidersConfig;
-};
-export type SubClassInstance<T extends typeof MeshOS> = T extends abstract new (...args: any) => infer R ? R : never;
-export type AllSubclassInstances = SubClassInstance<(typeof MeshOS)['classes'][keyof (typeof MeshOS)['classes']]>;
-export type EntityInstanceTypes = MeshOS;
-export type SubclassType<T extends MeshOS = MeshOS> = new (...args: any[]) => T;
-export type Entity = {
-    name: string;
-    label: string;
-    /**
-     * A more-specific value for workers when targeting version-specifc
-     * or priority-specific task queues.
-     * @default default
-     */
-    taskQueue?: string;
-    schema: WorkflowSearchSchema;
-    class: SubclassType;
-};
-export type Namespace = {
-    name: string;
-    /**
-     * @deprecated; unused; name is the type; label is human-readable
-     */
-    type: string;
-    label: string;
-    module: 'hotmesh' | 'meshcall' | 'memflow' | 'meshdata' | 'meshos';
-    entities: Entity[];
-};
-export type Namespaces = {
-    [key: string]: Namespace;
-};
-export type Instance = {
-    [key: string]: EntityInstanceTypes;
-};
-export type Instances = {
-    [key: string]: Instance;
-};
-export type Profile = {
-    db: DB;
-    namespaces: Namespaces;
-    instances?: Instances;
-};
-export type Profiles = {
-    [key: string]: Profile;
-};

package/build/types/manifest.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });