@hotmeshio/hotmesh 0.0.1

package/build/types/hotmesh.d.ts

@@ -0,0 +1,82 @@
+import { ILogger } from "../services/logger";
+import { HotMeshService } from "../services/hotmesh";
+import { HookRules } from "./hook";
+import { RedisClass, RedisClient, RedisOptions } from "./redis";
+import { StreamData, StreamDataResponse } from "./stream";
+type HotMesh = typeof HotMeshService;
+type RedisConfig = {
+    class: RedisClass;
+    options: RedisOptions;
+};
+type HotMeshEngine = {
+    store?: RedisClient;
+    stream?: RedisClient;
+    sub?: RedisClient;
+    redis?: RedisConfig;
+    reclaimDelay?: number;
+    reclaimCount?: number;
+};
+type HotMeshWorker = {
+    topic: string;
+    store?: RedisClient;
+    stream?: RedisClient;
+    sub?: RedisClient;
+    redis?: {
+        class: RedisClass;
+        options: RedisOptions;
+    };
+    reclaimDelay?: number;
+    reclaimCount?: number;
+    callback: (payload: StreamData) => Promise<StreamDataResponse | void>;
+};
+type HotMeshConfig = {
+    appId: string;
+    namespace?: string;
+    name?: string;
+    logger?: ILogger;
+    logLevel?: 'silly' | 'debug' | 'info' | 'warn' | 'error' | 'silent';
+    engine?: HotMeshEngine;
+    workers?: HotMeshWorker[];
+};
+type HotMeshGraph = {
+    subscribes: string;
+    publishes?: string;
+    expire?: number;
+    output?: {
+        schema: Record<string, any>;
+    };
+    input?: {
+        schema: Record<string, any>;
+    };
+    activities: Record<string, any>;
+    transitions?: Record<string, any>;
+    hooks?: HookRules;
+};
+type HotMeshSettings = {
+    namespace: string;
+    version: string;
+};
+type HotMeshManifest = {
+    app: {
+        id: string;
+        version: string;
+        settings: Record<string, any>;
+        graphs: HotMeshGraph[];
+    };
+};
+type VersionedFields = {
+    [K in `versions/${string}`]: any;
+};
+type HotMeshApp = VersionedFields & {
+    id: string;
+    version: string;
+    settings?: string;
+    active?: boolean;
+};
+type HotMeshApps = {
+    [appId: string]: HotMeshApp;
+};
+export { HotMesh, HotMeshEngine, RedisConfig, HotMeshWorker, HotMeshSettings, HotMeshApp, //a single app in the db
+HotMeshApps, //object array of all apps in the db
+HotMeshConfig, //customer config
+HotMeshManifest, HotMeshGraph };

package/build/types/hotmesh.js

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

package/build/types/index.d.ts

@@ -0,0 +1,20 @@
+export { ActivityType, ActivityDataType, ActivityContext, ActivityData, ActivityDuplex, ActivityLeg, ActivityMetadata, Consumes, AwaitActivity, BaseActivity, EmitActivity, WorkerActivity, IterateActivity, TriggerActivity, TriggerActivityStats } from './activity';
+export { App, AppVID, AppTransitions, AppSubscriptions } from './app';
+export { AsyncSignal } from './async';
+export { CacheMode } from './cache';
+export { CollationFaultType, CollationStage } from './collator';
+export { HookCondition, HookConditions, HookGate, HookInterface, HookRule, HookRules, HookSignal } from './hook';
+export { RedisClientType as IORedisClientType, RedisMultiType as IORedisMultiType } from './ioredisclient';
+export { ILogger } from './logger';
+export { JobData, JobsData, JobMetadata, JobOutput, JobState, JobStatus, PartialJobState } from './job';
+export { MappingStatements } from './map';
+export { Pipe, PipeItem, PipeItems } from './pipe';
+export { HotMesh, HotMeshApp, HotMeshApps, HotMeshConfig, HotMeshEngine, RedisConfig, HotMeshGraph, HotMeshManifest, HotMeshSettings, HotMeshWorker } from './hotmesh';
+export { ActivateMessage, JobMessage, JobMessageCallback, PingMessage, PongMessage, QuorumMessage, SubscriptionCallback, ThrottleMessage, WorkMessage } from './quorum';
+export { MultiResponseFlags, RedisClient, RedisMulti } from './redis';
+export { RedisClientType, RedisMultiType } from './redisclient';
+export { JSONSchema, StringAnyType, StringScalarType, StringStringType, SymbolMap, SymbolMaps, SymbolRanges, Symbols, SymbolSets } from './serializer';
+export { AggregatedData, CountByFacet, GetStatsOptions, IdsData, Measure, MeasureIds, MetricTypes, StatType, StatsType, IdsResponse, JobStats, JobStatsInput, JobStatsRange, StatsResponse, Segment, TimeSegment } from './stats';
+export { ReclaimedMessageType, StreamCode, StreamConfig, StreamData, StreamDataType, StreamError, StreamDataResponse, StreamRetryPolicy, StreamRole, StreamStatus } from './stream';
+export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType } from './telemetry';
+export { TransitionMatch, TransitionRule, Transitions } from './transition';

package/build/types/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = exports.StreamStatus = exports.StreamRole = exports.StreamDataType = exports.IORedisClientType = exports.HookGate = exports.CollationFaultType = void 0;
+var collator_1 = require("./collator");
+Object.defineProperty(exports, "CollationFaultType", { enumerable: true, get: function () { return collator_1.CollationFaultType; } });
+var hook_1 = require("./hook");
+Object.defineProperty(exports, "HookGate", { enumerable: true, get: function () { return hook_1.HookGate; } });
+var ioredisclient_1 = require("./ioredisclient");
+Object.defineProperty(exports, "IORedisClientType", { enumerable: true, get: function () { return ioredisclient_1.RedisClientType; } });
+var stream_1 = require("./stream");
+Object.defineProperty(exports, "StreamDataType", { enumerable: true, get: function () { return stream_1.StreamDataType; } });
+Object.defineProperty(exports, "StreamRole", { enumerable: true, get: function () { return stream_1.StreamRole; } });
+Object.defineProperty(exports, "StreamStatus", { enumerable: true, get: function () { return stream_1.StreamStatus; } });
+var telemetry_1 = require("./telemetry");
+Object.defineProperty(exports, "context", { enumerable: true, get: function () { return telemetry_1.context; } });
+Object.defineProperty(exports, "metrics", { enumerable: true, get: function () { return telemetry_1.metrics; } });
+Object.defineProperty(exports, "propagation", { enumerable: true, get: function () { return telemetry_1.propagation; } });
+Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return telemetry_1.SpanStatusCode; } });
+Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return telemetry_1.SpanKind; } });
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return telemetry_1.trace; } });
+Object.defineProperty(exports, "ValueType", { enumerable: true, get: function () { return telemetry_1.ValueType; } });

package/build/types/ioredisclient.d.ts

@@ -0,0 +1,5 @@
+import { Redis, ChainableCommander, RedisOptions } from 'ioredis';
+type RedisClassType = {
+    new (options: RedisOptions): Redis;
+};
+export { RedisClassType, Redis as RedisClientType, ChainableCommander as RedisMultiType, RedisOptions as RedisClientOptions, };

package/build/types/ioredisclient.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClientType = void 0;
+const ioredis_1 = require("ioredis");
+Object.defineProperty(exports, "RedisClientType", { enumerable: true, get: function () { return ioredis_1.Redis; } });

package/build/types/job.d.ts

@@ -0,0 +1,50 @@
+type JobData = Record<string, unknown | Record<string, unknown>>;
+type JobsData = Record<string, unknown>;
+type ActivityData = {
+    data: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+};
+type JobMetadata = {
+    key?: string;
+    jid: string;
+    dad: string;
+    aid: string;
+    pj?: string;
+    pd?: string;
+    pa?: string;
+    ngn?: string;
+    app: string;
+    vrs: string;
+    tpc: string;
+    ts: string;
+    jc: string;
+    ju: string;
+    js: JobStatus;
+    atp: string;
+    stp: string;
+    spn: string;
+    trc: string;
+    err?: string;
+    expire?: number;
+};
+type JobStatus = number;
+type JobState = {
+    metadata: JobMetadata;
+    data: JobData;
+    [activityId: symbol]: {
+        input: ActivityData;
+        output: ActivityData;
+        hook: ActivityData;
+        settings: ActivityData;
+        errors: ActivityData;
+    };
+};
+type JobOutput = {
+    metadata: JobMetadata;
+    data: JobData;
+};
+type PartialJobState = {
+    metadata: JobMetadata | Pick<JobMetadata, 'jid' | 'dad' | 'aid'>;
+    data: JobData;
+};
+export { JobState, JobStatus, JobData, JobsData, JobMetadata, PartialJobState, JobOutput };

package/build/types/job.js

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

package/build/types/logger.d.ts

@@ -0,0 +1,6 @@
+export interface ILogger {
+    info(message: string, ...meta: any[]): void;
+    error(message: string, ...meta: any[]): void;
+    warn(message: string, ...meta: any[]): void;
+    debug(message: string, ...meta: any[]): void;
+}

package/build/types/logger.js

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

package/build/types/map.d.ts

@@ -0,0 +1,4 @@
+type MappingStatements = {
+    [activityId: string]: string[];
+};
+export { MappingStatements };

package/build/types/map.js

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

package/build/types/pipe.d.ts

@@ -0,0 +1,4 @@
+type PipeItem = string | boolean | number | null;
+type PipeItems = PipeItem[];
+type Pipe = (PipeItem[] | Pipe)[];
+export { Pipe, PipeItem, PipeItems };

package/build/types/pipe.js

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

package/build/types/quorum.d.ts

@@ -0,0 +1,46 @@
+import { JobOutput } from "./job";
+/**
+ * The types in this file are used to define those messages that are sent
+ * to hotmesh client instances when a new version is about to be activated.
+ * These messages serve to coordinate the cache invalidation and switch-over
+ * to the new version without any downtime and a coordinating parent server.
+ */
+export type QuorumMessage = PingMessage | PongMessage | ActivateMessage | WorkMessage | JobMessage | ThrottleMessage;
+export interface PingMessage {
+    type: 'ping';
+    originator: string;
+}
+export interface WorkMessage {
+    type: 'work';
+    originator: string;
+}
+export interface PongMessage {
+    type: 'pong';
+    originator: string;
+    guid: string;
+}
+export interface ActivateMessage {
+    type: 'activate';
+    cache_mode: 'nocache' | 'cache';
+    until_version: string;
+}
+export interface JobMessage {
+    type: 'job';
+    topic: string;
+    job: JobOutput;
+}
+export interface ThrottleMessage {
+    type: 'throttle';
+    guid?: string;
+    topic?: string;
+    throttle: number;
+}
+export interface JobMessageCallback {
+    (topic: string, message: JobOutput): void;
+}
+export interface SubscriptionCallback {
+    (topic: string, message: Record<string, any>): void;
+}
+export interface QuorumMessageCallback {
+    (topic: string, message: QuorumMessage): void;
+}

package/build/types/quorum.js

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

package/build/types/redis.d.ts

@@ -0,0 +1,8 @@
+import { RedisClassType, RedisClientType as RCT, RedisMultiType as RMT, RedisClientOptions as RCO } from './redisclient';
+import { RedisClassType as IORRedisClassType, RedisClientType as IORCT, RedisMultiType as IORMT, RedisClientOptions as IORCO } from './ioredisclient';
+type RedisClass = RedisClassType | IORRedisClassType;
+type RedisClient = RCT | IORCT;
+type RedisMulti = RMT | IORMT;
+type RedisOptions = RCO | IORCO;
+type MultiResponseFlags = (string | number)[];
+export { RedisClass, RedisClient, RedisMulti, RedisOptions, MultiResponseFlags, };

package/build/types/redis.js

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

package/build/types/redisclient.d.ts

@@ -0,0 +1,25 @@
+import { createClient, RedisClientOptions } from 'redis';
+type RedisClientType = ReturnType<typeof createClient>;
+interface RedisMultiType {
+    XADD(key: string, id: string, fields: any): this;
+    XACK(key: string, group: string, id: string): this;
+    XDEL(key: string, id: string): this;
+    HDEL(key: string, itemId: string): this;
+    HGET(key: string, itemId: string): this;
+    HGETALL(key: string): this;
+    HINCRBYFLOAT(key: string, itemId: string, value: number): this;
+    HMGET(key: string, itemIds: string[]): this;
+    HSET(key: string, values: Record<string, string>): this;
+    LRANGE(key: string, start: number, end: number): this;
+    RPUSH(key: string, value: string): this;
+    ZADD(key: string, values: {
+        score: string;
+        value: string;
+    }): this;
+    sendCommand(command: string[]): Promise<any>;
+    exec: () => Promise<unknown[]>;
+}
+type RedisClassType = {
+    createClient: (options: RedisClientOptions) => any;
+};
+export { RedisClassType, RedisClientType, RedisMultiType, RedisClientOptions, };

package/build/types/redisclient.js

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

package/build/types/serializer.d.ts

@@ -0,0 +1,33 @@
+export interface JSONSchema {
+    type?: string;
+    enum?: string[];
+    examples?: any[];
+    properties?: {
+        [key: string]: JSONSchema;
+    };
+    items?: JSONSchema;
+    description?: string;
+    'x-train'?: boolean;
+}
+export type SymbolRanges = {
+    [key: string]: number;
+};
+export type Symbols = {
+    [key: string]: string;
+};
+export type SymbolSets = {
+    [key: string]: {
+        [key: string]: string;
+    };
+};
+export type StringStringType = {
+    [key: string]: string;
+};
+export type StringAnyType = {
+    [key: string]: any;
+};
+export type StringScalarType = {
+    [key: string]: boolean | number | string;
+};
+export type SymbolMap = Map<string, string>;
+export type SymbolMaps = Map<string, SymbolMap>;

package/build/types/serializer.js

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

package/build/types/stats.d.ts

@@ -0,0 +1,83 @@
+type MetricTypes = 'count' | 'sum' | 'avg' | 'mdn' | 'max' | 'min' | 'index';
+interface StatType {
+    target: string;
+    metric: MetricTypes;
+    value: number | string;
+}
+interface Measure {
+    target: string;
+    type: string;
+    value: number;
+}
+interface Segment {
+    time: string;
+    count: number;
+    measures: Measure[];
+}
+interface StatsType {
+    general: StatType[];
+    index: StatType[];
+    median: StatType[];
+}
+interface JobStats {
+    count?: number;
+    [field: string]: number;
+}
+interface JobStatsRange {
+    [key: string]: JobStats;
+}
+interface JobStatsInput {
+    data: Record<string, unknown>;
+    range?: string;
+    start?: string;
+    end?: string;
+    sparse?: boolean;
+}
+interface GetStatsOptions {
+    key: string;
+    granularity: string;
+    range?: string;
+    start?: string;
+    end?: string;
+    sparse?: boolean;
+}
+interface StatsResponse {
+    key: string;
+    granularity: string;
+    range: string;
+    end: string | Date;
+    count: number;
+    measures: Measure[];
+    segments?: Segment[];
+}
+interface AggregatedData {
+    [key: string]: number;
+}
+interface IdsData {
+    [target: string]: string[];
+}
+interface MeasureIds {
+    time: string;
+    target: string;
+    count: number;
+    type: 'ids';
+    ids: string[];
+}
+interface TimeSegment {
+    time: string;
+    measures: MeasureIds[];
+}
+interface CountByFacet {
+    facet: string;
+    count: number;
+}
+interface IdsResponse {
+    key: string;
+    facets: string[];
+    granularity: string;
+    range: string;
+    start: string;
+    counts: CountByFacet[];
+    segments: TimeSegment[];
+}
+export { StatsType, StatType, MetricTypes, JobStats, JobStatsRange, JobStatsInput, GetStatsOptions, StatsResponse, AggregatedData, Measure, Segment, IdsData, MeasureIds, TimeSegment, IdsResponse, CountByFacet };

package/build/types/stats.js

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

package/build/types/stream.d.ts

@@ -0,0 +1,67 @@
+export interface StreamRetryPolicy {
+    [key: string]: [number, 'x'];
+}
+export type StreamCode = number;
+export type StreamError = {
+    message: string;
+    code: number;
+    job_id?: string;
+    stack?: string;
+    name?: string;
+    error?: Record<string, unknown>;
+};
+export declare enum StreamStatus {
+    SUCCESS = "success",
+    ERROR = "error",
+    PENDING = "pending"
+}
+export declare enum StreamDataType {
+    TIMEHOOK = "timehook",
+    WEBHOOK = "webhook",
+    AWAIT = "await",
+    RESULT = "result",
+    WORKER = "worker",
+    RESPONSE = "response",
+    TRANSITION = "transition"
+}
+export interface StreamData {
+    metadata: {
+        topic?: string;
+        jid?: string;
+        dad?: string;
+        aid: string;
+        trc?: string;
+        spn?: string;
+        try?: number;
+    };
+    type?: StreamDataType;
+    data: Record<string, unknown>;
+    policies?: {
+        retry?: StreamRetryPolicy;
+    };
+    status?: StreamStatus;
+    code?: number;
+}
+export interface StreamDataResponse extends StreamData {
+}
+export declare enum StreamRole {
+    WORKER = "worker",
+    ENGINE = "engine",
+    SYSTEM = "system"
+}
+export type ReclaimedMessageType = [
+    messageId: string,
+    details: [
+        key: string,
+        value: string
+    ]
+][];
+export type StreamConfig = {
+    namespace: string;
+    appId: string;
+    guid: string;
+    role: StreamRole;
+    topic?: string;
+    reclaimDelay?: number;
+    reclaimCount?: number;
+};

package/build/types/stream.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamRole = exports.StreamDataType = exports.StreamStatus = void 0;
+var StreamStatus;
+(function (StreamStatus) {
+    StreamStatus["SUCCESS"] = "success";
+    StreamStatus["ERROR"] = "error";
+    StreamStatus["PENDING"] = "pending";
+})(StreamStatus = exports.StreamStatus || (exports.StreamStatus = {}));
+var StreamDataType;
+(function (StreamDataType) {
+    StreamDataType["TIMEHOOK"] = "timehook";
+    StreamDataType["WEBHOOK"] = "webhook";
+    StreamDataType["AWAIT"] = "await";
+    StreamDataType["RESULT"] = "result";
+    StreamDataType["WORKER"] = "worker";
+    StreamDataType["RESPONSE"] = "response";
+    StreamDataType["TRANSITION"] = "transition";
+})(StreamDataType = exports.StreamDataType || (exports.StreamDataType = {}));
+var StreamRole;
+(function (StreamRole) {
+    StreamRole["WORKER"] = "worker";
+    StreamRole["ENGINE"] = "engine";
+    StreamRole["SYSTEM"] = "system";
+})(StreamRole = exports.StreamRole || (exports.StreamRole = {}));

package/build/types/telemetry.d.ts

@@ -0,0 +1 @@
+export { context, Context, Counter, Meter, metrics, propagation, SpanContext, Span, SpanStatus, SpanStatusCode, SpanKind, trace, Tracer, ValueType } from '@opentelemetry/api';

package/build/types/telemetry.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueType = exports.trace = exports.SpanKind = exports.SpanStatusCode = exports.propagation = exports.metrics = exports.context = void 0;
+var api_1 = require("@opentelemetry/api");
+Object.defineProperty(exports, "context", { enumerable: true, get: function () { return api_1.context; } });
+Object.defineProperty(exports, "metrics", { enumerable: true, get: function () { return api_1.metrics; } });
+Object.defineProperty(exports, "propagation", { enumerable: true, get: function () { return api_1.propagation; } });
+Object.defineProperty(exports, "SpanStatusCode", { enumerable: true, get: function () { return api_1.SpanStatusCode; } });
+Object.defineProperty(exports, "SpanKind", { enumerable: true, get: function () { return api_1.SpanKind; } });
+Object.defineProperty(exports, "trace", { enumerable: true, get: function () { return api_1.trace; } });
+Object.defineProperty(exports, "ValueType", { enumerable: true, get: function () { return api_1.ValueType; } });

package/build/types/transition.d.ts

@@ -0,0 +1,17 @@
+import { Pipe } from "./pipe";
+export type TransitionMatch = {
+    expected: boolean | string | number | null;
+    actual: boolean | string | number | null | {
+        '@pipe': Pipe;
+    };
+};
+export type TransitionRule = {
+    gate?: 'and' | 'or';
+    code?: string;
+    match: Array<TransitionMatch>;
+};
+export type Transitions = {
+    [key: string]: {
+        [key: string]: TransitionRule;
+    };
+};

package/build/types/transition.js

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

package/index.ts

@@ -0,0 +1,5 @@
+import { Durable } from './services/durable';
+import { HotMeshService as HotMesh } from './services/hotmesh';
+import { HotMeshConfig } from './types/hotmesh';
+
+export { Durable, HotMesh, HotMeshConfig };

package/modules/errors.ts

@@ -0,0 +1,55 @@
+import { ActivityDuplex } from "../types/activity";
+import { CollationFaultType, CollationStage } from "../types/collator";
+
+class GetStateError extends Error {
+  constructor() {
+    super("Error occurred while getting job state");
+  }
+}
+class SetStateError extends Error {
+  constructor() {
+    super("Error occurred while setting job state");
+  }
+}
+
+class MapDataError extends Error {
+  constructor() {
+    super("Error occurred while mapping data");
+  }
+}
+
+class RegisterTimeoutError extends Error {
+  constructor() {
+    super("Error occurred while registering activity timeout");
+  }
+}
+
+class DuplicateJobError extends Error {
+  constructor(jobId: string) {
+    super("Duplicate job");
+    this.message = `Duplicate job: ${jobId}`;
+  }
+}
+
+class ExecActivityError extends Error {
+  constructor() {
+    super("Error occurred while executing activity");
+  }
+}
+
+class CollationError extends Error {
+  status: number; //15-digit activity collation integer (889000001000001)
+  leg: ActivityDuplex;
+  stage: CollationStage; //enter | exit | confirm
+  fault: CollationFaultType; //missing, invalid, etc
+
+  constructor(status: number, leg: ActivityDuplex, stage: CollationStage, fault?: CollationFaultType) {
+    super("collation-error");
+    this.leg = leg;
+    this.status = status;
+    this.stage = stage;
+    this.fault = fault;
+  }
+}
+
+export { CollationError, DuplicateJobError, GetStateError, SetStateError, MapDataError, RegisterTimeoutError, ExecActivityError };