@hatchet-dev/typescript-sdk 1.29.0 → 1.29.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hatchet-dev/typescript-sdk",
-  "version": "1.29.0",
+  "version": "1.29.1",
   "description": "Background task orchestration & visibility for developers",
   "types": "dist/index.d.ts",
   "files": [

package/v1/embedded.d.ts

@@ -39,11 +39,13 @@ export interface EmbeddedSidecar {
     stop: () => Promise<void>;
 }
 /**
- * Downloads (and caches) the hatchet-embedded sidecar binary, spawns it, and
- * waits until the embedded engine is ready. The sidecar shuts down when this
- * process exits. Use `HatchetEmbedded()` unless you need the raw
- * connection details.
+ * Gracefully stops every sidecar started in this process by
+ * `HatchetEmbeddedClient.init()` (or `startEmbeddedSidecar`) and resolves once
+ * they have fully exited, including their bundled Postgres. Call this before
+ * your process exits so the engine's shutdown output does not print after
+ * your program has returned.
  */
+export declare function stopEmbeddedSidecar(): Promise<void>;
 export declare function startEmbeddedSidecar(opts?: EmbeddedOptions): Promise<EmbeddedSidecar>;
 export declare class HatchetEmbeddedClient {
     /**
@@ -56,5 +58,14 @@ export declare class HatchetEmbeddedClient {
      * @param axiosConfig - Optional Axios configuration for HTTP requests.
      * @returns A new Hatchet client instance connected to the embedded engine.
      */
-    static init<T extends Record<string, any> = {}, U extends Record<string, any> = {}>(embeddedOpts?: EmbeddedOptions, config?: Omit<Partial<ClientConfig>, 'middleware'>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): Promise<HatchetClient<T, U>>;
+    static init<T extends Record<string, any> = {}, U extends Record<string, any> = {}>(embeddedOpts?: EmbeddedOptions, config?: Omit<Partial<ClientConfig>, 'middleware'>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): Promise<EmbeddedClient<T, U>>;
 }
+export type EmbeddedClient<T extends Record<string, any> = {}, U extends Record<string, any> = {}> = HatchetClient<T, U> & {
+    /**
+     * Gracefully stops the embedded engine sidecar and resolves once it has
+     * fully exited, including its bundled Postgres. Call this before your
+     * process exits so the engine's shutdown output does not print after your
+     * program has returned.
+     */
+    stopEmbedded: () => Promise<void>;
+};

package/v1/embedded.js

@@ -50,6 +50,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HatchetEmbeddedClient = void 0;
+exports.stopEmbeddedSidecar = stopEmbeddedSidecar;
 exports.startEmbeddedSidecar = startEmbeddedSidecar;
 const child_process_1 = require("child_process");
 const client_1 = require("./client/client");
@@ -216,6 +217,21 @@ function waitForHandshake(child, handshakePath, timeoutMs) {
  * process exits. Use `HatchetEmbedded()` unless you need the raw
  * connection details.
  */
+const activeSidecars = new Set();
+/**
+ * Gracefully stops every sidecar started in this process by
+ * `HatchetEmbeddedClient.init()` (or `startEmbeddedSidecar`) and resolves once
+ * they have fully exited, including their bundled Postgres. Call this before
+ * your process exits so the engine's shutdown output does not print after
+ * your program has returned.
+ */
+function stopEmbeddedSidecar() {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const sidecar of [...activeSidecars]) {
+            yield sidecar.stop();
+        }
+    });
+}
 function startEmbeddedSidecar() {
     return __awaiter(this, arguments, void 0, function* (opts = {}) {
         var _a, _b;
@@ -275,27 +291,34 @@ function startEmbeddedSidecar() {
         if (child.stdin instanceof net_1.Socket) {
             child.stdin.unref();
         }
-        return {
+        let stopping;
+        const sidecar = {
             token: handshake.token,
             tenantId: handshake.tenant_id,
             grpcAddress: handshake.grpc_address,
             apiUrl: handshake.api_url,
-            stop: () => new Promise((resolve) => {
-                var _a;
-                process.removeListener('exit', killChild);
-                if (child.exitCode !== null) {
-                    resolve();
-                    return;
-                }
-                const forceKill = setTimeout(() => child.kill('SIGKILL'), 30000);
-                (_a = forceKill.unref) === null || _a === void 0 ? void 0 : _a.call(forceKill);
-                child.once('exit', () => {
-                    clearTimeout(forceKill);
-                    resolve();
-                });
-                child.kill();
-            }),
+            stop: () => {
+                stopping !== null && stopping !== void 0 ? stopping : (stopping = new Promise((resolve) => {
+                    var _a;
+                    activeSidecars.delete(sidecar);
+                    process.removeListener('exit', killChild);
+                    if (child.exitCode !== null) {
+                        resolve();
+                        return;
+                    }
+                    const forceKill = setTimeout(() => child.kill('SIGKILL'), 30000);
+                    (_a = forceKill.unref) === null || _a === void 0 ? void 0 : _a.call(forceKill);
+                    child.once('exit', () => {
+                        clearTimeout(forceKill);
+                        resolve();
+                    });
+                    child.kill();
+                }));
+                return stopping;
+            },
         };
+        activeSidecars.add(sidecar);
+        return sidecar;
     });
 }
 class HatchetEmbeddedClient {
@@ -312,7 +335,9 @@ class HatchetEmbeddedClient {
     static init(embeddedOpts, config, options, axiosConfig) {
         return __awaiter(this, void 0, void 0, function* () {
             const sidecar = yield startEmbeddedSidecar(embeddedOpts);
-            return client_1.HatchetClient.init(Object.assign(Object.assign(Object.assign({ token: sidecar.token, tenant_id: sidecar.tenantId, host_port: sidecar.grpcAddress }, (sidecar.apiUrl ? { api_url: sidecar.apiUrl } : {})), { tls_config: { tls_strategy: 'none' } }), config), options, axiosConfig);
+            const client = client_1.HatchetClient.init(Object.assign(Object.assign(Object.assign({ token: sidecar.token, tenant_id: sidecar.tenantId, host_port: sidecar.grpcAddress }, (sidecar.apiUrl ? { api_url: sidecar.apiUrl } : {})), { tls_config: { tls_strategy: 'none' } }), config), options, axiosConfig);
+            client.stopEmbedded = () => sidecar.stop();
+            return client;
         });
     }
 }

package/v1/examples/embedded/worker.d.ts

@@ -0,0 +1,2 @@
+export declare function configuredClient(): Promise<import("../../embedded").EmbeddedClient<{}, {}>>;
+export declare function fleetClient(): Promise<import("../../embedded").EmbeddedClient<{}, {}>>;

package/v1/examples/embedded/worker.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configuredClient = configuredClient;
+exports.fleetClient = fleetClient;
+const embedded_1 = require("../../embedded");
+function configuredClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Configure the embedded engine
+        const hatchet = yield embedded_1.HatchetEmbeddedClient.init({
+            // use your own Postgres instead of the bundled one
+            databaseUrl: 'postgres://...',
+            // store the bundled Postgres runtime and data under this directory
+            postgresDataDir: '~/my-project/.hatchet-pg',
+            // use RabbitMQ instead of the Postgres message queue
+            rabbitmqUrl: 'amqp://...',
+            // bind the API / gRPC servers to specific ports
+            apiPort: 28243,
+            grpcPort: 7070,
+            // start only the engine + gRPC, no REST API
+            startApi: false,
+            // skip running migrations on startup
+            runMigrations: false,
+            // engine log level (default "warn")
+            logLevel: 'info',
+            // hatchet-embedded release tag to download
+            version: 'v0.105.0',
+            // use an existing sidecar binary, skips the download
+            binaryPath: '/path/to/hatchet-embedded-sidecar',
+            // pinned sha256 of the sidecar binary, replaces checksums.txt as the trust anchor
+            checksum: '4f2a...',
+        });
+        // !!
+        return hatchet;
+    });
+}
+function fleetClient() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Fleet with a shared database
+        const hatchet = yield embedded_1.HatchetEmbeddedClient.init({
+            databaseUrl: 'postgres://user:pass@db.internal:5432/hatchet',
+        });
+        // !!
+        return hatchet;
+    });
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        // > Create an embedded client
+        const hatchet = yield embedded_1.HatchetEmbeddedClient.init();
+        // !!
+        const greet = hatchet.task({
+            name: 'embedded-greet',
+            fn: (input) => ({ greeting: `Hello, ${input.name}!` }),
+        });
+        const worker = yield hatchet.worker('embedded-worker', { workflows: [greet] });
+        void worker.start();
+        const result = yield greet.run({ name: 'embed' });
+        console.log(result.greeting);
+        // > Stop the embedded engine
+        yield hatchet.stopEmbedded();
+        // !!
+        process.exit(0);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/version.d.ts

@@ -1 +1 @@
-export declare const HATCHET_VERSION = "1.29.0";
+export declare const HATCHET_VERSION = "1.29.1";

package/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HATCHET_VERSION = void 0;
-exports.HATCHET_VERSION = '1.29.0';
+exports.HATCHET_VERSION = '1.29.1';