@hotmeshio/hotmesh 0.12.1 → 0.14.0

package/build/services/engine/state.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Job state retrieval, export, and symbol compression.
+ *
+ * Provides read access to job data at various granularities:
+ *   - `getState()`      → full hydrated job tree
+ *   - `getQueryState()` → specific fields only
+ *   - `getRaw()`        → raw hash data (no hydration)
+ *   - `getStatus()`     → job status code only
+ *   - `export()`        → full export via ExporterService
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compress = exports.getQueryState = exports.getState = exports.getStatus = exports.getRaw = exports.exportJob = void 0;
+const utils_1 = require("../../modules/utils");
+const serializer_1 = require("../serializer");
+async function exportJob(instance, jobId, options = {}) {
+    return await instance.exporter.export(jobId, options);
+}
+exports.exportJob = exportJob;
+async function getRaw(instance, jobId) {
+    return await instance.store.getRaw(jobId);
+}
+exports.getRaw = getRaw;
+async function getStatus(instance, jobId) {
+    const { id: appId } = await instance.getVID();
+    return await instance.store.getStatus(jobId, appId);
+}
+exports.getStatus = getStatus;
+async function getState(instance, topic, jobId) {
+    const jobSymbols = await instance.store.getSymbols(`$${topic}`);
+    const consumes = {
+        [`$${topic}`]: Object.keys(jobSymbols),
+    };
+    const dIds = {};
+    const output = await instance.store.getState(jobId, consumes, dIds);
+    if (!output) {
+        throw new Error(`not found ${jobId}`);
+    }
+    const [state, status] = output;
+    const stateTree = (0, utils_1.restoreHierarchy)(state);
+    if (status != null && stateTree.metadata) {
+        stateTree.metadata.js = status;
+    }
+    return stateTree;
+}
+exports.getState = getState;
+async function getQueryState(instance, jobId, fields) {
+    return await instance.store.getQueryState(jobId, fields);
+}
+exports.getQueryState = getQueryState;
+/**
+ * @deprecated
+ */
+async function compress(instance, terms) {
+    const existingSymbols = await instance.store.getSymbolValues();
+    const startIndex = Object.keys(existingSymbols).length;
+    const maxIndex = Math.pow(52, 2) - 1;
+    const newSymbols = serializer_1.SerializerService.filterSymVals(startIndex, maxIndex, existingSymbols, new Set(terms));
+    return await instance.store.addSymbolValues(newSymbols);
+}
+exports.compress = compress;

package/build/services/engine/version.d.ts

@@ -0,0 +1,31 @@
+/**
+ * App version resolution and distributed cache management.
+ *
+ * The engine caches the deployed app version locally to avoid
+ * hitting the store on every message. During hot-deploys the cache
+ * switches to `nocache` mode until the target version appears,
+ * then resumes caching.
+ */
+import { ILogger } from '../logger';
+import { StoreService } from '../store';
+import { AppVID } from '../../types/app';
+import { CacheMode } from '../../types/cache';
+import { HotMeshApps } from '../../types/hotmesh';
+import { ProviderClient, ProviderTransaction } from '../../types/provider';
+interface VersionContext {
+    appId: string;
+    guid: string;
+    apps: HotMeshApps | null;
+    cacheMode: CacheMode;
+    untilVersion: string | null;
+    store: StoreService<ProviderClient, ProviderTransaction>;
+    logger: ILogger;
+}
+/**
+ * Resolves the distributed executable version, retrying with a delay
+ * to allow deployment race conditions to settle.
+ */
+export declare function fetchAndVerifyVID(instance: VersionContext, vid: AppVID, count?: number): Promise<AppVID>;
+export declare function getVID(instance: VersionContext, vid?: AppVID): Promise<AppVID>;
+export declare function setCacheMode(instance: VersionContext, cacheMode: CacheMode, untilVersion: string): void;
+export {};

package/build/services/engine/version.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * App version resolution and distributed cache management.
+ *
+ * The engine caches the deployed app version locally to avoid
+ * hitting the store on every message. During hot-deploys the cache
+ * switches to `nocache` mode until the target version appears,
+ * then resumes caching.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCacheMode = exports.getVID = exports.fetchAndVerifyVID = void 0;
+const enums_1 = require("../../modules/enums");
+const utils_1 = require("../../modules/utils");
+/**
+ * Resolves the distributed executable version, retrying with a delay
+ * to allow deployment race conditions to settle.
+ */
+async function fetchAndVerifyVID(instance, vid, count = 0) {
+    if (isNaN(Number(vid.version))) {
+        const app = await instance.store.getApp(vid.id, true);
+        if (!isNaN(Number(app.version))) {
+            if (!instance.apps)
+                instance.apps = {};
+            instance.apps[vid.id] = app;
+            return { id: vid.id, version: app.version };
+        }
+        else if (count < 10) {
+            await (0, utils_1.sleepFor)(enums_1.HMSH_QUORUM_DELAY_MS * 2);
+            return await fetchAndVerifyVID(instance, vid, count + 1);
+        }
+        else {
+            instance.logger.error('engine-vid-resolution-error', {
+                id: vid.id,
+                guid: instance.guid,
+            });
+        }
+    }
+    return vid;
+}
+exports.fetchAndVerifyVID = fetchAndVerifyVID;
+async function getVID(instance, vid) {
+    if (instance.cacheMode === 'nocache') {
+        const app = await instance.store.getApp(instance.appId, true);
+        if (app.version.toString() === instance.untilVersion.toString()) {
+            if (!instance.apps)
+                instance.apps = {};
+            instance.apps[instance.appId] = app;
+            setCacheMode(instance, 'cache', app.version.toString());
+        }
+        return { id: instance.appId, version: app.version };
+    }
+    else if (!instance.apps && vid) {
+        instance.apps = {};
+        instance.apps[instance.appId] = vid;
+        return vid;
+    }
+    else {
+        return await fetchAndVerifyVID(instance, {
+            id: instance.appId,
+            version: instance.apps?.[instance.appId].version,
+        });
+    }
+}
+exports.getVID = getVID;
+function setCacheMode(instance, cacheMode, untilVersion) {
+    instance.logger.info(`engine-executable-cache`, {
+        mode: cacheMode,
+        [cacheMode === 'cache' ? 'target' : 'until']: untilVersion,
+    });
+    instance.cacheMode = cacheMode;
+    instance.untilVersion = untilVersion;
+}
+exports.setCacheMode = setCacheMode;

package/build/services/hotmesh/deployment.d.ts

@@ -0,0 +1,21 @@
+import { EngineService } from '../engine';
+import { QuorumService } from '../quorum';
+import { HotMeshManifest } from '../../types/hotmesh';
+interface DeploymentContext {
+    engine: EngineService | null;
+    quorum: QuorumService | null;
+}
+/**
+ * Preview changes and provide an analysis of risk prior to deployment.
+ * @private
+ */
+export declare function plan(instance: DeploymentContext, path: string): Promise<HotMeshManifest>;
+/**
+ * Deploys a YAML workflow graph to Postgres.
+ */
+export declare function deploy(instance: DeploymentContext, pathOrYAML: string): Promise<HotMeshManifest>;
+/**
+ * Activates a deployed version across the entire mesh.
+ */
+export declare function activate(instance: DeploymentContext, version: string, delay?: number): Promise<boolean>;
+export {};

package/build/services/hotmesh/deployment.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.activate = exports.deploy = exports.plan = void 0;
+/**
+ * Preview changes and provide an analysis of risk prior to deployment.
+ * @private
+ */
+async function plan(instance, path) {
+    return await instance.engine?.plan(path);
+}
+exports.plan = plan;
+/**
+ * Deploys a YAML workflow graph to Postgres.
+ */
+async function deploy(instance, pathOrYAML) {
+    return await instance.engine?.deploy(pathOrYAML);
+}
+exports.deploy = deploy;
+/**
+ * Activates a deployed version across the entire mesh.
+ */
+async function activate(instance, version, delay) {
+    return await instance.quorum?.activate(version, delay);
+}
+exports.activate = activate;