@hotmeshio/hotmesh 0.0.22 → 0.0.24

package/services/hotmesh/index.ts

@@ -21,6 +21,7 @@ import {
   StatsResponse } from '../../types/stats';
 import { ConnectorService } from '../connector';
 import { StreamCode, StreamData, StreamDataResponse, StreamStatus } from '../../types/stream';
+import { StringAnyType } from '../../types/serializer';
 
 class HotMeshService {
   namespace: string;
@@ -59,7 +60,7 @@ class HotMeshService {
     instance.logger = new LoggerService(config.appId, instance.guid, config.name || '', config.logLevel);
     await instance.initEngine(config, instance.logger);
     await instance.initQuorum(config, instance.engine, instance.logger);
-    await instance.initWorkers(config, instance.logger);
+    await instance.doWork(config, instance.logger);
     return instance;
   }
 
@@ -97,7 +98,7 @@ class HotMeshService {
     }
   }
 
-  async initWorkers(config: HotMeshConfig, logger: ILogger) {
+  async doWork(config: HotMeshConfig, logger: ILogger) {
     this.workers = await WorkerService.init(
       this.namespace,
       this.appId,
@@ -152,6 +153,9 @@ class HotMeshService {
   async getState(topic: string, jobId: string): Promise<JobOutput> {
     return this.engine?.getState(topic, jobId);
   }
+  async getQueryState(jobId: string, fields: string[]): Promise<StringAnyType> {
+    return await this.engine?.getQueryState(jobId, fields);
+  }
   async getIds(topic: string, query: JobStatsInput, queryFacets = []): Promise<IdsResponse> {
     return await this.engine?.getIds(topic, query, queryFacets);
   }

package/services/signaler/stream.ts

@@ -61,7 +61,7 @@ class StreamSignaler {
     try {
       await this.store.xgroup('CREATE', stream, group, '$', 'MKSTREAM');
     } catch (err) {
-      this.logger.info('consumer-group-exists', { stream, group });
+      this.logger.debug('consumer-group-exists', { stream, group });
     }
   }
 
@@ -150,7 +150,6 @@ class StreamSignaler {
     try {
       output = await callback(input);
     } catch (error) {
-      console.error(error);
       this.logger.error(`stream-call-function-error`, { error });
       output = this.structureUnhandledError(input, error);
     }

package/services/store/clients/ioredis.ts

@@ -5,7 +5,6 @@ import { Cache } from '../cache';
 import { StoreService } from '../index';
 import { RedisClientType, RedisMultiType } from '../../../types/ioredisclient';
 import { ReclaimedMessageType } from '../../../types/stream';
-import { type } from 'os';
 
 class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
   redisClient: RedisClientType;
@@ -60,14 +59,14 @@ class IORedisStoreService extends StoreService<RedisClientType, RedisMultiType>
       try {
         return (await this.redisClient.xgroup(command, key, groupName, id, mkStream)) === 'OK';
       } catch (err) {
-        this.logger.info(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
+        this.logger.debug(`Consumer group not created with MKSTREAM for key: ${key} and group: ${groupName}`);
         throw err;
       }
     } else {
       try {
         return (await this.redisClient.xgroup(command, key, groupName, id)) === 'OK';
       } catch (err) {
-        this.logger.info(`Consumer group not created for key: ${key} and group: ${groupName}`);
+        this.logger.debug(`Consumer group not created for key: ${key} and group: ${groupName}`);
         throw err;
       }
     }

package/services/store/clients/redis.ts

@@ -86,7 +86,7 @@ class RedisStoreService extends StoreService<RedisClientType, RedisMultiType> {
       return (await this.redisClient.sendCommand(['XGROUP', 'CREATE', key, groupName, id, ...args])) === 1;
     } catch (error) {
       const streamType = mkStream === 'MKSTREAM' ? 'with MKSTREAM' : 'without MKSTREAM';
-      this.logger.info(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
+      this.logger.debug(`x-group-error ${streamType} for key: ${key} and group: ${groupName}`, { error });
       throw error;
     }
   }

package/services/store/index.ts

@@ -476,6 +476,21 @@ abstract class StoreService<T, U extends AbstractRedisClient> {
     return jobId;
   }
 
+  /**
+   * returns custom search fields and values. The fields param
+   * should not prefix items with an underscore.
+   */
+  async getQueryState(jobId: string, fields: string[]): Promise<StringAnyType> {
+    const key = this.mintKey(KeyType.JOB_STATE, { appId: this.appId, jobId });
+    const _fields = fields.map(field => `_${field}`);
+    const jobDataArray = await this.redisClient[this.commands.hmget](key, _fields);
+    const jobData: StringAnyType = {};
+    fields.forEach((field, index) => {
+      jobData[field] = jobDataArray[index];
+    });
+    return jobData;
+  }
+
   async getState(jobId: string, consumes: Consumes, dIds: StringStringType): Promise<[StringAnyType, number] | undefined> {
     //get abbreviated field list (the symbols for the paths)
     const key = this.mintKey(KeyType.JOB_STATE, { appId: this.appId, jobId });

package/types/durable.ts

@@ -10,7 +10,7 @@ type WorkflowConfig = {
 type WorkflowSearchOptions = {
   index?: string;         //FT index name (myapp:myindex)
   prefix?: string[];      //FT prefixes (['myapp:myindex:prefix1', 'myapp:myindex:prefix2'])
-  schema?: Record<string, {type: 'TEXT' | 'NUMERIC' | 'TAG', sortable: boolean}>;
+  schema?: Record<string, {type: 'TEXT' | 'NUMERIC' | 'TAG', sortable?: boolean}>;
   data?: Record<string, string>;
 }
 
@@ -57,12 +57,27 @@ type WorkflowDataType = {
   workflowTopic: string;
 }
 
+type MeshOSClassConfig = {
+  namespace: string;
+  taskQueue: string;
+  redisOptions: RedisOptions;
+  redisClass: RedisClass;
+}
+
+type MeshOSConfig = {
+  taskQueue?: string;
+  index?: {
+    index: string;
+    prefix: string[];
+    schema: Record<string, {type: 'TEXT' | 'NUMERIC' | 'TAG', sortable: boolean}>;
+  };
+}
+
 type ConnectionConfig = {
   class: RedisClass;
   options: RedisOptions;
 }
 type Connection =  ConnectionConfig;
-type NativeConnection =  ConnectionConfig;
 
 type ClientConfig = {
   connection: Connection;
@@ -76,11 +91,28 @@ type WorkerConfig = {
   connection: Connection;
   namespace?: string; //`appid` in the YAML (e.g, 'default')
   taskQueue: string; //`subscribes` in the YAML (e.g, 'hello-world')
-  workflow: Function; //target function to run
+  workflow: Function | Record<string | symbol, Function>; //target function to run
   options?: WorkerOptions;
   search?: WorkflowSearchOptions;
 }
 
+type FindOptions = {
+  workflowName?: string; //also the function name
+  taskQueue?: string;
+  namespace?: string;
+  index?: string;        //the FT search index name
+}
+
+type MeshOSOptions = {
+  name: string;
+  options: WorkerOptions;
+}
+
+type MeshOSActivityOptions = {
+  name: string;
+  options: ActivityConfig;
+}
+
 type WorkerOptions = {
   logLevel?: string; //debug, info, warn, error
   maxSystemRetries?: number; //1-3 (10ms, 100ms, 1_000ms)
@@ -115,11 +147,15 @@ export {
   ContextType,
   ConnectionConfig,
   Connection,
-  NativeConnection,
   ProxyType,
   Registry,
   SignalOptions,
+  FindOptions,
   HookOptions,
+  MeshOSActivityOptions,
+  MeshOSClassConfig,
+  MeshOSConfig,
+  MeshOSOptions,
   WorkerConfig,
   WorkflowConfig,
   WorkerOptions,

package/types/index.ts

@@ -34,10 +34,15 @@ export {
     ContextType,
     ConnectionConfig,
     Connection,
-    NativeConnection,
     ProxyType,
     Registry,
+    SignalOptions,
+    FindOptions,
     HookOptions,
+    MeshOSActivityOptions,
+    MeshOSClassConfig,
+    MeshOSConfig,
+    MeshOSOptions,
     WorkflowConfig,
     WorkerConfig,
     WorkerOptions,

package/build/services/durable/native.d.ts

@@ -1,4 +0,0 @@
-import { Connection, ConnectionConfig } from "../../types/durable";
-export declare class NativeConnectionService {
-    static connect(config: ConnectionConfig): Promise<Connection>;
-}

package/build/services/durable/native.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NativeConnectionService = void 0;
-/*
-
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as workflows from './workflows';
-
-async function run() {
-  const connection = await NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-  const worker = await Worker.create({
-    connection,
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-    activities,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-
-*/
-class NativeConnectionService {
-    static async connect(config) {
-        return {
-            class: config.class,
-            options: { ...config.options },
-        };
-    }
-}
-exports.NativeConnectionService = NativeConnectionService;

package/services/durable/native.ts

@@ -1,45 +0,0 @@
-import { Connection, ConnectionConfig } from "../../types/durable";
-
-/*
-
-Here is an example of how the methods in this file are used:
-
-./worker.ts
-
-import { Durable: { NativeConnection, Worker } } from '@hotmeshio/hotmesh';
-import Redis from 'ioredis'; //OR `import * as Redis from 'redis';`
-
-import * as workflows from './workflows';
-
-async function run() {
-  const connection = await NativeConnection.connect({
-    class: Redis,
-    options: {
-      host: 'localhost',
-      port: 6379,
-    },
-  });
-  const worker = await Worker.create({
-    connection,
-    taskQueue: 'hello-world',
-    workflow: workflows.example,
-    activities,
-  });
-  await worker.run();
-}
-
-run().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
-
-*/
-
-export class NativeConnectionService {
-  static async connect(config: ConnectionConfig): Promise<Connection> {
-    return {
-      class: config.class,
-      options: { ...config.options },
-     } as Connection;
-  }
-}