@hatchet-dev/typescript-sdk 0.1.11 → 0.1.13

package/clients/admin/admin-client.d.ts

@@ -1,12 +1,83 @@
 import { Channel, ClientFactory } from 'nice-grpc';
 import { CreateWorkflowVersionOpts, WorkflowServiceClient } from '../../protoc/workflows';
 import { ClientConfig } from '../hatchet-client/client-config';
+import { Api } from '../rest';
+/**
+ * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
+ * and monitor workflows.
+ * The admin client can be accessed via:
+ * ```typescript
+ * const hatchet = Hatchet.init()
+ * const admin = hatchet.admin as AdminClient;
+ *
+ * // Now you can use the admin client to interact with the Hatchet Admin API
+ * admin.list_workflows().then((res) => {
+ *   res.rows?.forEach((row) => {
+ *     console.log(row);
+ *   });
+ * });
+ * ```
+ */
 export declare class AdminClient {
     config: ClientConfig;
     client: WorkflowServiceClient;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
+    api: Api;
+    tenantId: string;
+    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory, api: Api, tenantId: string);
+    /**
+     * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
+     * determine if the workflow definition has changed and create a new version if necessary.
+     * @param workflow a workflow definition to create
+     */
     put_workflow(workflow: CreateWorkflowVersionOpts): Promise<void>;
+    /**
+     * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
+     * new run.
+     * @param workflowName the name of the workflow to run
+     * @param input an object containing the input to the workflow
+     * @returns the ID of the new workflow run
+     */
     run_workflow(workflowName: string, input: object): Promise<string>;
+    /**
+     * List workflows in the tenant associated with the API token.
+     * @returns a list of all workflows in the tenant
+     */
+    list_workflows(): Promise<import("../rest/generated/data-contracts").WorkflowList>;
+    /**
+     * Get a workflow by its ID.
+     * @param workflowId the workflow ID (**note:** this is not the same as the workflow version id)
+     * @returns
+     */
+    get_workflow(workflowId: string): Promise<import("../rest/generated/data-contracts").Workflow>;
+    /**
+     * Get a workflow version.
+     * @param workflowId the workflow ID
+     * @param version the version of the workflow to get. If not provided, the latest version will be returned.
+     * @returns the workflow version
+     */
+    get_workflow_version(workflowId: string, version?: string): Promise<import("../rest/generated/data-contracts").WorkflowVersion>;
+    /**
+     * Get a workflow run.
+     * @param workflowRunId the id of the workflow run to get
+     * @returns the workflow run
+     */
+    get_workflow_run(workflowRunId: string): Promise<import("../rest/generated/data-contracts").WorkflowRun>;
+    /**
+     * List workflow runs in the tenant associated with the API token.
+     * @param query the query to filter the list of workflow runs
+     * @returns
+     */
+    list_workflow_runs(query: {
+        offset?: number | undefined;
+        limit?: number | undefined;
+        eventId?: string | undefined;
+        workflowId?: string | undefined;
+    }): Promise<import("../rest/generated/data-contracts").WorkflowRunList>;
+    /**
+     * Schedule a workflow to run at a specific time or times.
+     * @param workflowId the ID of the workflow to schedule
+     * @param options an object containing the schedules to set
+     */
     schedule_workflow(workflowId: string, options?: {
         schedules?: Date[];
     }): void;

package/clients/admin/admin-client.js

@@ -15,11 +15,34 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdminClient = void 0;
 const workflows_1 = require("../../protoc/workflows");
 const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
+/**
+ * AdminClient is a client for interacting with the Hatchet Admin API. This allows you to configure, trigger,
+ * and monitor workflows.
+ * The admin client can be accessed via:
+ * ```typescript
+ * const hatchet = Hatchet.init()
+ * const admin = hatchet.admin as AdminClient;
+ *
+ * // Now you can use the admin client to interact with the Hatchet Admin API
+ * admin.list_workflows().then((res) => {
+ *   res.rows?.forEach((row) => {
+ *     console.log(row);
+ *   });
+ * });
+ * ```
+ */
 class AdminClient {
-    constructor(config, channel, factory) {
+    constructor(config, channel, factory, api, tenantId) {
         this.config = config;
         this.client = factory.create(workflows_1.WorkflowServiceDefinition, channel);
+        this.api = api;
+        this.tenantId = tenantId;
     }
+    /**
+     * Creates a new workflow or updates an existing workflow. If the workflow already exists, Hatchet will automatically
+     * determine if the workflow definition has changed and create a new version if necessary.
+     * @param workflow a workflow definition to create
+     */
     put_workflow(workflow) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -32,6 +55,13 @@ class AdminClient {
             }
         });
     }
+    /**
+     * Run a new instance of a workflow with the given input. This will create a new workflow run and return the ID of the
+     * new run.
+     * @param workflowName the name of the workflow to run
+     * @param input an object containing the input to the workflow
+     * @returns the ID of the new workflow run
+     */
     run_workflow(workflowName, input) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
@@ -47,7 +77,68 @@ class AdminClient {
             }
         });
     }
-    // RunWorkflow(workflowName string, input interface{}) (string, error)
+    /**
+     * List workflows in the tenant associated with the API token.
+     * @returns a list of all workflows in the tenant
+     */
+    list_workflows() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.api.workflowList(this.tenantId);
+            return res.data;
+        });
+    }
+    /**
+     * Get a workflow by its ID.
+     * @param workflowId the workflow ID (**note:** this is not the same as the workflow version id)
+     * @returns
+     */
+    get_workflow(workflowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.api.workflowGet(workflowId);
+            return res.data;
+        });
+    }
+    /**
+     * Get a workflow version.
+     * @param workflowId the workflow ID
+     * @param version the version of the workflow to get. If not provided, the latest version will be returned.
+     * @returns the workflow version
+     */
+    get_workflow_version(workflowId, version) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.api.workflowVersionGet(workflowId, {
+                version,
+            });
+            return res.data;
+        });
+    }
+    /**
+     * Get a workflow run.
+     * @param workflowRunId the id of the workflow run to get
+     * @returns the workflow run
+     */
+    get_workflow_run(workflowRunId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.api.workflowRunGet(this.tenantId, workflowRunId);
+            return res.data;
+        });
+    }
+    /**
+     * List workflow runs in the tenant associated with the API token.
+     * @param query the query to filter the list of workflow runs
+     * @returns
+     */
+    list_workflow_runs(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.api.workflowRunList(this.tenantId, query);
+            return res.data;
+        });
+    }
+    /**
+     * Schedule a workflow to run at a specific time or times.
+     * @param workflowId the ID of the workflow to schedule
+     * @param options an object containing the schedules to set
+     */
     schedule_workflow(workflowId, options) {
         try {
             this.client.scheduleWorkflow({

package/clients/admin/index.d.ts

@@ -0,0 +1 @@
+export * from './admin-client';

package/clients/admin/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./admin-client"), exports);

package/clients/hatchet-client/client-config.d.ts

@@ -41,7 +41,9 @@ export declare const ClientConfigSchema: z.ZodObject<{
         server_name?: string | undefined;
     }>;
     host_port: z.ZodString;
+    api_url: z.ZodString;
     log_level: z.ZodOptional<z.ZodEnum<["OFF", "DEBUG", "INFO", "WARN", "ERROR"]>>;
+    tenant_id: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     token: string;
     tls_config: {
@@ -52,6 +54,8 @@ export declare const ClientConfigSchema: z.ZodObject<{
         server_name?: string | undefined;
     };
     host_port: string;
+    api_url: string;
+    tenant_id: string;
     log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
 }, {
     token: string;
@@ -63,6 +67,8 @@ export declare const ClientConfigSchema: z.ZodObject<{
         server_name?: string | undefined;
     };
     host_port: string;
+    api_url: string;
+    tenant_id: string;
     log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
 }>;
 export type ClientConfig = z.infer<typeof ClientConfigSchema> & {

package/clients/hatchet-client/client-config.js

@@ -13,5 +13,7 @@ exports.ClientConfigSchema = zod_1.z.object({
     token: zod_1.z.string(),
     tls_config: ClientTLSConfigSchema,
     host_port: zod_1.z.string(),
+    api_url: zod_1.z.string(),
     log_level: zod_1.z.enum(['OFF', 'DEBUG', 'INFO', 'WARN', 'ERROR']).optional(),
+    tenant_id: zod_1.z.string(),
 });

package/clients/hatchet-client/hatchet-client.d.ts

@@ -5,8 +5,10 @@ import { Channel, ChannelCredentials } from 'nice-grpc';
 import { Workflow } from '../../workflow';
 import { Worker } from '../worker';
 import Logger from '../../util/logger/logger';
+import { AxiosRequestConfig } from 'axios';
 import { ClientConfig } from './client-config';
 import { ListenerClient } from '../listener/listener-client';
+import { Api } from '../rest/generated/Api';
 export interface HatchetClientOptions {
     config_path?: string;
     credentials?: ChannelCredentials;
@@ -18,11 +20,13 @@ export declare class HatchetClient {
     event: EventClient;
     dispatcher: DispatcherClient;
     admin: AdminClient;
+    api: Api;
     listener: ListenerClient;
+    tenantId: string;
     logger: Logger;
-    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions);
+    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosOpts?: AxiosRequestConfig);
     static with_host_port(host: string, port: number, config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
+    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions, axiosConfig?: AxiosRequestConfig): HatchetClient;
     run(workflow: string | Workflow): Promise<Worker>;
     worker(workflow: string | Workflow): Promise<Worker>;
 }

package/clients/hatchet-client/hatchet-client.js

@@ -48,6 +48,7 @@ const worker_1 = require("../worker");
 const logger_1 = __importDefault(require("../../util/logger/logger"));
 const client_config_1 = require("./client-config");
 const listener_client_1 = require("../listener/listener-client");
+const rest_1 = __importDefault(require("../rest"));
 const addTokenMiddleware = (token) => function _(call, options) {
     return __asyncGenerator(this, arguments, function* _1() {
         var _a, e_1, _b, _c;
@@ -75,11 +76,11 @@ const addTokenMiddleware = (token) => function _(call, options) {
     });
 };
 class HatchetClient {
-    constructor(config, options) {
+    constructor(config, options, axiosOpts) {
         // Initializes a new Client instance.
         // Loads config in the following order: config param > yaml file > env vars
         var _a;
-        const loaded = config_loader_1.ConfigLoader.load_client_config({
+        const loaded = config_loader_1.ConfigLoader.loadClientConfig({
             path: options === null || options === void 0 ? void 0 : options.config_path,
         });
         try {
@@ -98,9 +99,11 @@ class HatchetClient {
             'grpc.ssl_target_name_override': this.config.tls_config.server_name,
         });
         const clientFactory = (0, nice_grpc_1.createClientFactory)().use(addTokenMiddleware(this.config.token));
+        this.tenantId = this.config.tenant_id;
+        this.api = (0, rest_1.default)(this.config.api_url, this.config.token, axiosOpts);
         this.event = new event_client_1.EventClient(this.config, this.channel, clientFactory);
         this.dispatcher = new dispatcher_client_1.DispatcherClient(this.config, this.channel, clientFactory);
-        this.admin = new admin_client_1.AdminClient(this.config, this.channel, clientFactory);
+        this.admin = new admin_client_1.AdminClient(this.config, this.channel, clientFactory, this.api, this.tenantId);
         this.listener = new listener_client_1.ListenerClient(this.config, this.channel, clientFactory);
         this.logger = new logger_1.default('HatchetClient', this.config.log_level);
         this.logger.info(`Initialized HatchetClient`);
@@ -108,8 +111,8 @@ class HatchetClient {
     static with_host_port(host, port, config, options) {
         return new HatchetClient(Object.assign(Object.assign({}, config), { host_port: `${host}:${port}` }), options);
     }
-    static init(config, options) {
-        return new HatchetClient(config, options);
+    static init(config, options, axiosConfig) {
+        return new HatchetClient(config, options, axiosConfig);
     }
     run(workflow) {
         return __awaiter(this, void 0, void 0, function* () {

package/clients/listener/listener-client.js

@@ -40,7 +40,7 @@ class ListenerClient {
     constructor(config, channel, factory) {
         this.config = config;
         this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
-        this.logger = new logger_1.Logger(`Dispatcher`, config.log_level);
+        this.logger = new logger_1.Logger(`Listener`, config.log_level);
     }
     on(workflowRunId, handler) {
         var _a, e_1, _b, _c;

package/clients/rest/api.d.ts

@@ -0,0 +1,4 @@
+import { AxiosRequestConfig } from 'axios';
+import { Api } from './generated/Api';
+declare const api: (serverUrl: string, token: string, axiosOpts?: AxiosRequestConfig) => Api<unknown>;
+export default api;

package/clients/rest/api.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const qs_1 = __importDefault(require("qs"));
+const Api_1 = require("./generated/Api");
+const api = (serverUrl, token, axiosOpts) => {
+    return new Api_1.Api(Object.assign({ baseURL: serverUrl, headers: {
+            Authorization: `Bearer ${token}`,
+        }, paramsSerializer: (params) => qs_1.default.stringify(params, { arrayFormat: 'repeat' }) }, axiosOpts));
+};
+exports.default = api;