@hatchet-dev/typescript-sdk 1.15.2 → 1.17.0

package/util/abort-error.js

@@ -1,17 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortError = void 0;
 exports.createAbortError = createAbortError;
 exports.isAbortError = isAbortError;
 exports.rethrowIfAborted = rethrowIfAborted;
+exports.bindAbortSignalHandler = bindAbortSignalHandler;
 exports.throwIfAborted = throwIfAborted;
+const events_1 = require("events");
+class AbortError extends Error {
+    constructor(message = 'Operation aborted') {
+        super(message);
+        this.code = 'ABORT_ERR';
+        this.name = 'AbortError';
+    }
+}
+exports.AbortError = AbortError;
 function createAbortError(message = 'Operation aborted') {
-    const err = new Error(message);
-    err.name = 'AbortError';
-    err.code = 'ABORT_ERR';
-    return err;
+    return new AbortError(message);
 }
 function isAbortError(err) {
-    return err instanceof Error && (err.name === 'AbortError' || err.code === 'ABORT_ERR');
+    if (err instanceof AbortError) {
+        return true;
+    }
+    return (err instanceof Error &&
+        (err.name === 'AbortError' || err.code === 'ABORT_ERR'));
 }
 /**
  * Helper to be used inside broad `catch` blocks so cancellation isn't accidentally swallowed.
@@ -26,6 +38,19 @@ function rethrowIfAborted(err) {
         throw err;
     }
 }
+/**
+ * Attach an `abort` listener to a signal, disabling the Node.js
+ * `MaxListenersExceededWarning` first.
+ *
+ * A single durable task can attach many concurrent listeners to the same signal
+ * (fan-out children, parallel waitFor calls, etc.), easily exceeding the default
+ * cap of 10. Setting max to 0 (unlimited) is safe here because every listener is
+ * removed on settlement.
+ */
+function bindAbortSignalHandler(signal, handler) {
+    (0, events_1.setMaxListeners)(0, signal);
+    signal.addEventListener('abort', handler, { once: true });
+}
 /**
  * Throws an AbortError if the provided signal is aborted.
  *

package/util/config-loader/config-loader.js

@@ -74,7 +74,7 @@ class ConfigLoader {
             apiUrl =
                 (_x = (_w = (_v = override === null || override === void 0 ? void 0 : override.api_url) !== null && _v !== void 0 ? _v : yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _w !== void 0 ? _w : this.env('HATCHET_CLIENT_API_URL')) !== null && _x !== void 0 ? _x : addresses.serverUrl;
         }
-        catch (e) {
+        catch (_9) {
             grpcBroadcastAddress =
                 (_z = (_y = override === null || override === void 0 ? void 0 : override.host_port) !== null && _y !== void 0 ? _y : yaml === null || yaml === void 0 ? void 0 : yaml.host_port) !== null && _z !== void 0 ? _z : this.env('HATCHET_CLIENT_HOST_PORT');
             apiUrl = (_1 = (_0 = override === null || override === void 0 ? void 0 : override.api_url) !== null && _0 !== void 0 ? _0 : yaml === null || yaml === void 0 ? void 0 : yaml.api_url) !== null && _1 !== void 0 ? _1 : this.env('HATCHET_CLIENT_API_URL');
@@ -119,10 +119,11 @@ class ConfigLoader {
             return config;
         }
         catch (e) {
-            if (!path)
+            if (!path) {
                 return undefined;
+            }
             if (e instanceof zod_1.z.ZodError) {
-                throw new Error(`Invalid yaml config: ${e.message}`);
+                throw new Error(`Invalid yaml config: ${e.message}`, { cause: e });
             }
             throw e;
         }

package/util/config-loader/token.js

@@ -2,12 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getTenantIdFromJWT = getTenantIdFromJWT;
 exports.getAddressesFromJWT = getAddressesFromJWT;
+const parse_1 = require("../parse");
 function getTenantIdFromJWT(token) {
     const claims = extractClaimsFromJWT(token);
+    if (claims.sub === undefined) {
+        throw new Error('Invalid token: missing sub');
+    }
     return claims.sub;
 }
 function getAddressesFromJWT(token) {
     const claims = extractClaimsFromJWT(token);
+    if (claims.server_url === undefined || claims.grpc_broadcast_address === undefined) {
+        throw new Error('Invalid token: missing server_url or grpc_broadcast_address');
+    }
     return {
         serverUrl: claims.server_url,
         grpcBroadcastAddress: claims.grpc_broadcast_address,
@@ -18,8 +25,8 @@ function extractClaimsFromJWT(token) {
     if (parts.length !== 3) {
         throw new Error('Invalid token format');
     }
-    const claimsPart = parts[1];
+    const [_, claimsPart] = parts;
     const claimsData = atob(claimsPart.replace(/-/g, '+').replace(/_/g, '/'));
-    const claims = JSON.parse(claimsData);
+    const claims = (0, parse_1.parseJSON)(claimsData);
     return claims;
 }

package/util/errors/eviction-not-supported-error.d.ts

@@ -0,0 +1,5 @@
+import HatchetError from './hatchet-error';
+export declare class EvictionNotSupportedError extends HatchetError {
+    engineVersion: string | undefined;
+    constructor(engineVersion?: string);
+}

package/util/errors/eviction-not-supported-error.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvictionNotSupportedError = void 0;
+const v1_1 = require("../../v1");
+const hatchet_error_1 = __importDefault(require("./hatchet-error"));
+class EvictionNotSupportedError extends hatchet_error_1.default {
+    constructor(engineVersion) {
+        const versionInfo = engineVersion ? ` (engine ${engineVersion})` : '';
+        super(`Durable eviction is not supported by the connected engine${versionInfo}. ` +
+            `Please upgrade your Hatchet engine to ${v1_1.MinEngineVersion.DURABLE_EVICTION} or later.`);
+        this.name = 'EvictionNotSupportedError';
+        this.engineVersion = engineVersion;
+    }
+}
+exports.EvictionNotSupportedError = EvictionNotSupportedError;

package/util/errors/hatchet-error.d.ts

@@ -1,4 +1,12 @@
+/** Returns a string message from an unknown value (e.g. from a catch block). */
+export declare function getErrorMessage(e: unknown): string;
 declare class HatchetError extends Error {
-    constructor(message: string);
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
 }
+export declare function toHatchetError(e: unknown, defaultMessageOrOptions?: string | {
+    defaultMessage?: string;
+    prefix?: string;
+}): HatchetError;
 export default HatchetError;

package/util/errors/hatchet-error.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorMessage = getErrorMessage;
+exports.toHatchetError = toHatchetError;
+/** Returns a string message from an unknown value (e.g. from a catch block). */
+function getErrorMessage(e) {
+    return e instanceof Error ? e.message : String(e);
+}
 class HatchetError extends Error {
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
         this.name = 'HatchetError';
     }
 }
+function toHatchetError(e, defaultMessageOrOptions = 'An error occurred') {
+    var _a;
+    if (e instanceof HatchetError) {
+        return e;
+    }
+    const opts = typeof defaultMessageOrOptions === 'string'
+        ? { defaultMessage: defaultMessageOrOptions }
+        : defaultMessageOrOptions;
+    const defaultMessage = (_a = opts.defaultMessage) !== null && _a !== void 0 ? _a : 'An error occurred';
+    let message = getErrorMessage(e) || defaultMessage;
+    if (opts.prefix) {
+        message = opts.prefix + message;
+    }
+    return new HatchetError(message, { cause: e });
+}
 exports.default = HatchetError;

package/util/errors/non-determinism-error.d.ts

@@ -0,0 +1,7 @@
+import HatchetError from './hatchet-error';
+export declare class NonDeterminismError extends HatchetError {
+    taskExternalId: string;
+    invocationCount: number;
+    nodeId: number;
+    constructor(taskExternalId: string, invocationCount: number, nodeId: number, message: string);
+}

package/util/errors/non-determinism-error.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonDeterminismError = void 0;
+const hatchet_error_1 = __importDefault(require("./hatchet-error"));
+class NonDeterminismError extends hatchet_error_1.default {
+    constructor(taskExternalId, invocationCount, nodeId, message) {
+        const detail = message
+            ? message
+            : `Non-determinism detected in task ${taskExternalId} on invocation ${invocationCount} at node ${nodeId}`;
+        super(`${detail}\n` +
+            `Check out our documentation for more details on expectations of durable tasks: https://docs.hatchet.run/v1/patterns/mixing-patterns`);
+        this.name = 'NonDeterminismError';
+        this.taskExternalId = taskExternalId;
+        this.invocationCount = invocationCount;
+        this.nodeId = nodeId;
+    }
+}
+exports.NonDeterminismError = NonDeterminismError;

package/util/errors/task-run-terminated-error.d.ts

@@ -0,0 +1,6 @@
+export type TaskRunTerminationReason = 'cancelled' | 'evicted';
+export declare class TaskRunTerminatedError extends Error {
+    readonly reason: TaskRunTerminationReason;
+    constructor(reason: TaskRunTerminationReason, message?: string);
+}
+export declare function isTaskRunTerminatedError(err: unknown): err is TaskRunTerminatedError;

package/util/errors/task-run-terminated-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskRunTerminatedError = void 0;
+exports.isTaskRunTerminatedError = isTaskRunTerminatedError;
+class TaskRunTerminatedError extends Error {
+    constructor(reason, message) {
+        super(message !== null && message !== void 0 ? message : reason);
+        this.name = 'TaskRunTerminatedError';
+        this.reason = reason;
+    }
+}
+exports.TaskRunTerminatedError = TaskRunTerminatedError;
+function isTaskRunTerminatedError(err) {
+    return err instanceof TaskRunTerminatedError;
+}

package/util/grpc-error.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the gRPC status code from an unknown value (e.g. from a catch block).
+ * Used for checking Status.CANCELLED, Status.UNAVAILABLE, etc.
+ */
+export declare function getGrpcErrorCode(e: unknown): number | undefined;
+/**
+ * Returns the gRPC error details string from an unknown value (e.g. from a catch block).
+ */
+export declare function getGrpcErrorDetails(e: unknown): string | undefined;

package/util/grpc-error.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGrpcErrorCode = getGrpcErrorCode;
+exports.getGrpcErrorDetails = getGrpcErrorDetails;
+/**
+ * Returns the gRPC status code from an unknown value (e.g. from a catch block).
+ * Used for checking Status.CANCELLED, Status.UNAVAILABLE, etc.
+ */
+function getGrpcErrorCode(e) {
+    if (e != null && typeof e === 'object' && 'code' in e) {
+        const { code } = e;
+        return typeof code === 'number' ? code : undefined;
+    }
+    return undefined;
+}
+/**
+ * Returns the gRPC error details string from an unknown value (e.g. from a catch block).
+ */
+function getGrpcErrorDetails(e) {
+    if (e != null && typeof e === 'object' && 'details' in e) {
+        const { details } = e;
+        return typeof details === 'string' ? details : undefined;
+    }
+    return undefined;
+}

package/util/hatchet-promise/hatchet-promise.d.ts

@@ -1,5 +1,10 @@
+/** Canonical reasons when cancelling a HatchetPromise (e.g. worker shutdown). */
+export declare enum CancellationReason {
+    CANCELLED_BY_WORKER = "Cancelled by worker",
+    EVICTED_BY_WORKER = "Evicted by worker"
+}
 declare class HatchetPromise<T> {
-    cancel: (reason?: any) => void;
+    cancel: (reason?: CancellationReason) => void;
     promise: Promise<T>;
     /**
      * The original (non-cancelable) promise passed to the constructor.

package/util/hatchet-promise/hatchet-promise.js

@@ -1,12 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CancellationReason = void 0;
+const task_run_terminated_error_1 = require("../errors/task-run-terminated-error");
+/** Canonical reasons when cancelling a HatchetPromise (e.g. worker shutdown). */
+var CancellationReason;
+(function (CancellationReason) {
+    CancellationReason["CANCELLED_BY_WORKER"] = "Cancelled by worker";
+    CancellationReason["EVICTED_BY_WORKER"] = "Evicted by worker";
+})(CancellationReason || (exports.CancellationReason = CancellationReason = {}));
+const reasonToTermination = {
+    [CancellationReason.CANCELLED_BY_WORKER]: 'cancelled',
+    [CancellationReason.EVICTED_BY_WORKER]: 'evicted',
+};
 class HatchetPromise {
     constructor(promise) {
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
         this.cancel = (_reason) => { };
         this.inner = Promise.resolve(promise);
         this.promise = new Promise((resolve, reject) => {
-            this.cancel = reject;
+            this.cancel = (reason) => {
+                const termination = reason ? reasonToTermination[reason] : 'cancelled';
+                reject(new task_run_terminated_error_1.TaskRunTerminatedError(termination, reason));
+            };
             this.inner.then(resolve).catch(reject);
         });
     }

package/util/logger/logger.js

@@ -4,7 +4,6 @@ exports.LogLevelEnum = exports.Logger = void 0;
 class Logger {
 }
 exports.Logger = Logger;
-// eslint-disable-next-line no-shadow
 var LogLevelEnum;
 (function (LogLevelEnum) {
     LogLevelEnum[LogLevelEnum["OFF"] = -1] = "OFF";

package/util/parse.d.ts

@@ -1 +1 @@
-export declare function parseJSON(json: string): any;
+export declare function parseJSON<T = any>(json: string): T;

package/util/parse.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseJSON = parseJSON;
+const hatchet_error_1 = require("./errors/hatchet-error");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function parseJSON(json) {
     try {
         const firstParse = JSON.parse(json);
@@ -9,11 +11,11 @@ function parseJSON(json) {
         try {
             return JSON.parse(firstParse);
         }
-        catch (e) {
+        catch (_a) {
             return firstParse;
         }
     }
     catch (e) {
-        throw new Error(`Could not parse JSON: ${e.message}`);
+        throw new Error(`Could not parse JSON: ${(0, hatchet_error_1.getErrorMessage)(e)}`, { cause: e });
     }
 }

package/util/retrier.js

@@ -20,14 +20,13 @@ const MAX_JITTER = 100; // milliseconds
 function retrier(fn_1, logger_1) {
     return __awaiter(this, arguments, void 0, function* (fn, logger, retries = DEFAULT_RETRY_COUNT, interval = DEFAULT_RETRY_INTERVAL) {
         let lastError;
-        // eslint-disable-next-line no-plusplus
         for (let i = 0; i < retries; i++) {
             try {
                 return yield fn();
             }
             catch (e) {
-                lastError = e;
-                logger.error(`Error: ${e.message}`);
+                lastError = e instanceof Error ? e : new Error(String(e));
+                logger.error(`Error: ${lastError.message}`);
                 // Calculate exponential backoff with random jitter
                 const exponentialDelay = interval * 2 ** i * 1000;
                 const jitter = Math.random() * MAX_JITTER;

package/util/sleep.d.ts

@@ -1,13 +1,14 @@
+import { Duration } from '../v1/client/duration';
 /**
  * Sleeps for a given number of milliseconds without blocking the event loop
  *
  * WARNING: This is not a durable sleep. It will not be honored if the worker is
  * restarted or crashes.
  *
- * @param ms - The number of milliseconds to sleep
+ * @param duration - The number of milliseconds to sleep, or a Duration (e.g. "5s", \{ seconds: 5 \})
  * @param signal - Optional AbortSignal; if aborted, the promise rejects with Error('Cancelled').
  *                 Use in task handlers so cancellation can interrupt long sleeps.
  * @returns A promise that resolves after the given number of milliseconds (or rejects on abort)
  */
-declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+declare function sleep(duration: number | Duration, signal?: AbortSignal): Promise<void>;
 export default sleep;

package/util/sleep.js

@@ -1,27 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const duration_1 = require("../v1/client/duration");
 /**
  * Sleeps for a given number of milliseconds without blocking the event loop
  *
  * WARNING: This is not a durable sleep. It will not be honored if the worker is
  * restarted or crashes.
  *
- * @param ms - The number of milliseconds to sleep
+ * @param duration - The number of milliseconds to sleep, or a Duration (e.g. "5s", \{ seconds: 5 \})
  * @param signal - Optional AbortSignal; if aborted, the promise rejects with Error('Cancelled').
  *                 Use in task handlers so cancellation can interrupt long sleeps.
  * @returns A promise that resolves after the given number of milliseconds (or rejects on abort)
  */
-function sleep(ms, signal) {
+function sleep(duration, signal) {
+    const timeout = typeof duration === 'number' ? duration : (0, duration_1.durationToMs)(duration);
     if (!signal) {
         return new Promise((resolve) => {
-            setTimeout(resolve, ms);
+            setTimeout(resolve, timeout);
         });
     }
     return new Promise((resolve, reject) => {
         const timer = setTimeout(() => {
             signal.removeEventListener('abort', onAbort);
             resolve();
-        }, ms);
+        }, timeout);
         const onAbort = () => {
             clearTimeout(timer);
             reject(new Error('Cancelled'));

package/util/workflow-run-ref.js

@@ -18,6 +18,7 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DedupeViolationErr = void 0;
 const nice_grpc_1 = require("nice-grpc");
+const grpc_error_1 = require("./grpc-error");
 const dispatcher_1 = require("../protoc/dispatcher");
 class DedupeViolationErr extends Error {
     constructor(message) {
@@ -28,6 +29,7 @@ class DedupeViolationErr extends Error {
 exports.DedupeViolationErr = DedupeViolationErr;
 function getWorkflowRunId(workflowRunId) {
     return __awaiter(this, void 0, void 0, function* () {
+        var _a;
         if (typeof workflowRunId === 'string') {
             return workflowRunId;
         }
@@ -40,8 +42,8 @@ function getWorkflowRunId(workflowRunId) {
                 return resolved.workflowRunId;
             }
             catch (e) {
-                if (e.code && e.code === nice_grpc_1.Status.ALREADY_EXISTS) {
-                    throw new DedupeViolationErr(e.details);
+                if ((0, grpc_error_1.getGrpcErrorCode)(e) === nice_grpc_1.Status.ALREADY_EXISTS) {
+                    throw new DedupeViolationErr((_a = (0, grpc_error_1.getGrpcErrorDetails)(e)) !== null && _a !== void 0 ? _a : '');
                 }
                 throw e;
             }
@@ -117,7 +119,7 @@ class WorkflowRunRef {
                                         try {
                                             outputs[readableStepName] = JSON.parse(stepRun.output || '{}');
                                         }
-                                        catch (error) {
+                                        catch (_c) {
                                             outputs[readableStepName] = stepRun.output;
                                         }
                                     });

package/v1/client/admin.d.ts

@@ -1,9 +1,9 @@
 import { ClientConfig } from '../../clients/hatchet-client/client-config';
 import WorkflowRunRef from '../../util/workflow-run-ref';
-import { Priority, RateLimitDuration, RunsClient } from './..';
+import { Priority, RateLimitDuration, RunsClient, WorkerLabelComparator } from './..';
 import { RunListenerClient } from '../../clients/listeners/run-listener/child-listener-client';
 import { Api } from '../../clients/rest/generated/Api';
-import { WorkerLabelComparator, WorkflowServiceClient } from '../../protoc/workflows';
+import { WorkflowServiceClient } from '../../protoc/workflows';
 import { AdminServiceClient, CreateWorkflowVersionRequest } from '../../protoc/v1/workflows';
 import { Logger } from '../../util/logger';
 type DesiredWorkerLabelOpt = {

package/v1/client/admin.js

@@ -91,9 +91,7 @@ class AdminClient {
                         : {} });
                 const resp = yield (0, retrier_1.retrier)(() => __awaiter(this, void 0, void 0, function* () { return this.workflowsGrpc.triggerWorkflow(request); }), this.logger);
                 const id = resp.workflowRunId;
-                const ref = new workflow_run_ref_1.default(id, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, 
-                // eslint-disable-next-line no-underscore-dangle
-                options === null || options === void 0 ? void 0 : options._standaloneTaskName);
+                const ref = new workflow_run_ref_1.default(id, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, options === null || options === void 0 ? void 0 : options._standaloneTaskName);
                 yield ref.getWorkflowRunId();
                 return ref;
             }
@@ -139,9 +137,7 @@ class AdminClient {
                     const batchResults = bulkTriggerWorkflowResponse.workflowRunIds.map((resp, index) => {
                         const originalIndex = originalIndices[index];
                         const { options } = workflowRuns[originalIndex];
-                        return new workflow_run_ref_1.default(resp, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, 
-                        // eslint-disable-next-line no-underscore-dangle
-                        options === null || options === void 0 ? void 0 : options._standaloneTaskName);
+                        return new workflow_run_ref_1.default(resp, this.listenerClient, this.runs, options === null || options === void 0 ? void 0 : options.parentId, options === null || options === void 0 ? void 0 : options._standaloneTaskName);
                     });
                     results.push(...batchResults);
                 }

package/v1/client/client.d.ts

@@ -17,19 +17,9 @@ import { CreateTaskWorkflowOpts, CreateWorkflowOpts, RunOpts, BaseWorkflowDeclar
 import type { LegacyWorkflow } from '../../legacy/legacy-transformer';
 import { IHatchetClient } from './client.interface';
 import { CreateWorkerOpts, Worker } from './worker/worker';
-import { MetricsClient } from './features/metrics';
-import { WorkersClient } from './features/workers';
-import { WorkflowsClient } from './features/workflows';
-import { RunsClient } from './features/runs';
+import { CELClient, CronClient, FiltersClient, LogsClient, MetricsClient, RatelimitsClient, RunsClient, ScheduleClient, TenantClient, WebhooksClient, WorkersClient, WorkflowsClient } from './features';
 import { InputType, OutputType, UnknownInputType, StrictWorkflowOutputType, Resolved } from '../types';
-import { RatelimitsClient } from './features';
 import { AdminClient } from './admin';
-import { FiltersClient } from './features/filters';
-import { ScheduleClient } from './features/schedules';
-import { CronClient } from './features/crons';
-import { CELClient } from './features/cel';
-import { TenantClient } from './features/tenant';
-import { WebhooksClient } from './features/webhooks';
 import { DurableContext } from './worker/context';
 type MergeIfNonEmpty<Base, Extra extends Record<string, any>> = keyof Extra extends never ? Base : Base & Extra;
 /**
@@ -256,6 +246,12 @@ export declare class HatchetClient<GlobalInput extends Record<string, any> = {},
      * @returns A webhooks client instance
      */
     get webhooks(): WebhooksClient;
+    private _logs;
+    /**
+     * Get the logs client for creating and managing logs
+     * @returns A logs client instance
+     */
+    get logs(): LogsClient;
     private _ratelimits;
     /**
      * Get the rate limits client for creating and managing rate limits

package/v1/client/client.interface.d.ts

@@ -2,15 +2,8 @@ import { EventClient } from '../../clients/event/event-client';
 import { DispatcherClient } from '../../clients/dispatcher/dispatcher-client';
 import { Logger } from '../../util/logger';
 import { LegacyHatchetClient } from '../../legacy/legacy-client';
-import { MetricsClient } from './features/metrics';
-import { RunsClient } from './features/runs';
-import { WorkersClient } from './features/workers';
-import { WorkflowsClient } from './features/workflows';
+import { CronClient, MetricsClient, RunsClient, ScheduleClient, WebhooksClient, WorkersClient, WorkflowsClient, CELClient, LogsClient, TenantClient, FiltersClient, RatelimitsClient } from './features';
 import { AdminClient } from './admin';
-import { ScheduleClient } from './features/schedules';
-import { CronClient } from './features/crons';
-import { CELClient } from './features/cel';
-import { WebhooksClient } from './features/webhooks';
 export interface IHatchetClient {
     /** @deprecated v0 client will be removed in a future release, please upgrade to v1 */
     v0: LegacyHatchetClient;
@@ -18,11 +11,15 @@ export interface IHatchetClient {
     dispatcher: DispatcherClient;
     events: EventClient;
     logger: Logger;
+    logs: LogsClient;
     metrics: MetricsClient;
     runs: RunsClient;
     workflows: WorkflowsClient;
     workers: WorkersClient;
     webhooks: WebhooksClient;
+    tenant: TenantClient;
+    filters: FiltersClient;
+    ratelimits: RatelimitsClient;
     scheduled: ScheduleClient;
     crons: CronClient;
     admin: AdminClient;