@hatchet-dev/typescript-sdk 0.0.2 → 0.0.7

package/dist/clients/dispatcher/dispatcher-client.d.ts

@@ -1,17 +0,0 @@
-import { Channel, ClientFactory } from 'nice-grpc';
-import { DispatcherClient as PbDispatcherClient, ActionEvent } from '@hatchet/protoc/dispatcher';
-import { ClientConfig } from '../hatchet-client/client-config';
-import { ActionListener } from './action-listener';
-interface GetActionListenerOptions {
-    workerName: string;
-    services: string[];
-    actions: string[];
-}
-export declare class DispatcherClient {
-    config: ClientConfig;
-    client: PbDispatcherClient;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
-    get_action_listener(options: GetActionListenerOptions): Promise<ActionListener>;
-    send_action_event(in_: ActionEvent): Promise<import("@hatchet/protoc/dispatcher").ActionEventResponse>;
-}
-export {};

package/dist/clients/dispatcher/dispatcher-client.js

@@ -1,46 +0,0 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DispatcherClient = void 0;
-const dispatcher_1 = require("@hatchet/protoc/dispatcher");
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-const action_listener_1 = require("./action-listener");
-class DispatcherClient {
-    constructor(config, channel, factory) {
-        this.config = config;
-        this.client = factory.create(dispatcher_1.DispatcherDefinition, channel);
-    }
-    get_action_listener(options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Register the worker
-            const registration = yield this.client.register(Object.assign({}, options));
-            // Subscribe to the worker
-            const listener = this.client.listen({
-                workerId: registration.workerId,
-            });
-            return new action_listener_1.ActionListener(this, listener, registration.workerId);
-        });
-    }
-    send_action_event(in_) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return this.client.sendActionEvent(in_);
-            }
-            catch (e) {
-                throw new hatchet_error_1.default(e.message);
-            }
-        });
-    }
-}
-exports.DispatcherClient = DispatcherClient;

package/dist/clients/dispatcher/dispatcher-client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/dispatcher/dispatcher-client.test.js

@@ -1,99 +0,0 @@
-"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 });
-const dispatcher_1 = require("@hatchet/protoc/dispatcher");
-const dispatcher_client_1 = require("./dispatcher-client");
-const hatchet_client_test_1 = require("../hatchet-client/hatchet-client.test");
-let client;
-describe('DispatcherClient', () => {
-    it('should create a client', () => {
-        const x = new dispatcher_client_1.DispatcherClient({
-            token: 'TOKEN',
-            host_port: 'HOST_PORT',
-            log_level: 'OFF',
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
-        expect(x).toBeDefined();
-    });
-    beforeEach(() => {
-        client = new dispatcher_client_1.DispatcherClient({
-            token: 'TOKEN',
-            host_port: 'HOST_PORT',
-            log_level: 'OFF',
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
-    });
-    describe('get_action_listener', () => {
-        it('should register the worker', () => __awaiter(void 0, void 0, void 0, function* () {
-            const clientSpy = jest.spyOn(client.client, 'register').mockResolvedValue({
-                workerId: 'WORKER_ID',
-                tenantId: 'TENANT_ID',
-                workerName: 'WORKER_NAME',
-            });
-            const listenerSpy = jest.spyOn(client.client, 'listen');
-            const listener = yield client.get_action_listener({
-                workerName: 'WORKER_NAME',
-                services: ['SERVICE'],
-                actions: ['ACTION'],
-            });
-            expect(clientSpy).toHaveBeenCalledWith({
-                workerName: 'WORKER_NAME',
-                services: ['SERVICE'],
-                actions: ['ACTION'],
-            });
-            expect(listenerSpy).toHaveBeenCalledWith({
-                workerId: 'WORKER_ID',
-            });
-            expect(listener).toBeDefined();
-            expect(listener.workerId).toEqual('WORKER_ID');
-        }));
-    });
-    describe('send_action_event', () => {
-        it('should send action events', () => {
-            const clientSpy = jest.spyOn(client.client, 'sendActionEvent').mockResolvedValue({
-                tenantId: 'TENANT_ID',
-                workerId: 'WORKER_ID',
-            });
-            client.send_action_event({
-                workerId: 'WORKER_ID',
-                actionId: 'ACTION_ID',
-                eventType: dispatcher_1.ActionEventType.STEP_EVENT_TYPE_COMPLETED,
-                eventPayload: '{"foo":"bar"}',
-                eventTimestamp: new Date(),
-                jobId: 'a',
-                jobRunId: 'b',
-                stepId: 'c',
-                stepRunId: 'd',
-            });
-            expect(clientSpy).toHaveBeenCalledWith({
-                workerId: 'WORKER_ID',
-                actionId: 'ACTION_ID',
-                eventType: dispatcher_1.ActionEventType.STEP_EVENT_TYPE_COMPLETED,
-                eventPayload: '{"foo":"bar"}',
-                jobId: 'a',
-                jobRunId: 'b',
-                stepId: 'c',
-                stepRunId: 'd',
-                eventTimestamp: expect.any(Object),
-            });
-        });
-    });
-});

package/dist/clients/event/event-client.d.ts

@@ -1,9 +0,0 @@
-import { Channel, ClientFactory } from 'nice-grpc';
-import { EventsServiceClient } from '@hatchet/protoc/events/events';
-import { ClientConfig } from '../hatchet-client/client-config';
-export declare class EventClient {
-    config: ClientConfig;
-    client: EventsServiceClient;
-    constructor(config: ClientConfig, channel: Channel, factory: ClientFactory);
-    push<T>(type: string, input: T): Promise<import("@hatchet/protoc/events/events").Event>;
-}

package/dist/clients/event/event-client.js

@@ -1,28 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventClient = void 0;
-const events_1 = require("@hatchet/protoc/events/events");
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-class EventClient {
-    constructor(config, channel, factory) {
-        this.config = config;
-        this.client = factory.create(events_1.EventsServiceDefinition, channel);
-    }
-    push(type, input) {
-        const req = {
-            key: type,
-            payload: JSON.stringify(input),
-            eventTimestamp: new Date(),
-        };
-        try {
-            return this.client.push(req);
-        }
-        catch (e) {
-            throw new hatchet_error_1.default(e.message);
-        }
-    }
-}
-exports.EventClient = EventClient;

package/dist/clients/event/event-client.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/clients/event/event-client.test.js

@@ -1,60 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const hatchet_error_1 = __importDefault(require("../../util/errors/hatchet-error"));
-const event_client_1 = require("./event-client");
-const hatchet_client_test_1 = require("../hatchet-client/hatchet-client.test");
-let client;
-describe('EventClient', () => {
-    it('should create a client', () => {
-        const x = new event_client_1.EventClient({
-            token: 'TOKEN',
-            host_port: 'HOST_PORT',
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
-        expect(x).toBeDefined();
-    });
-    beforeEach(() => {
-        client = new event_client_1.EventClient({
-            token: 'TOKEN',
-            host_port: 'HOST_PORT',
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, hatchet_client_test_1.mockChannel, hatchet_client_test_1.mockFactory);
-    });
-    it('should push events', () => {
-        const clientSpy = jest.spyOn(client.client, 'push').mockResolvedValue({
-            tenantId: 'x',
-            eventId: 'y',
-            key: 'z',
-            eventTimestamp: new Date(),
-            payload: 'string',
-        });
-        client.push('type', { foo: 'bar' });
-        expect(clientSpy).toHaveBeenCalledWith({
-            key: 'type',
-            payload: '{"foo":"bar"}',
-            eventTimestamp: expect.any(Date),
-        });
-    });
-    it('should throw an error when push fails', () => {
-        const clientSpy = jest.spyOn(client.client, 'push');
-        clientSpy.mockImplementation(() => {
-            throw new Error('foo');
-        });
-        expect(() => {
-            client.push('type', { foo: 'bar' });
-        }).toThrow(new hatchet_error_1.default('foo'));
-    });
-});

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

@@ -1,72 +0,0 @@
-import { ChannelCredentials } from 'nice-grpc';
-import { z } from 'zod';
-declare const ClientTLSConfigSchema: z.ZodObject<{
-    tls_strategy: z.ZodOptional<z.ZodEnum<["tls", "mtls"]>>;
-    cert_file: z.ZodOptional<z.ZodString>;
-    ca_file: z.ZodOptional<z.ZodString>;
-    key_file: z.ZodOptional<z.ZodString>;
-    server_name: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    tls_strategy?: "tls" | "mtls" | undefined;
-    cert_file?: string | undefined;
-    ca_file?: string | undefined;
-    key_file?: string | undefined;
-    server_name?: string | undefined;
-}, {
-    tls_strategy?: "tls" | "mtls" | undefined;
-    cert_file?: string | undefined;
-    ca_file?: string | undefined;
-    key_file?: string | undefined;
-    server_name?: string | undefined;
-}>;
-export declare const ClientConfigSchema: z.ZodObject<{
-    token: z.ZodString;
-    tls_config: z.ZodObject<{
-        tls_strategy: z.ZodOptional<z.ZodEnum<["tls", "mtls"]>>;
-        cert_file: z.ZodOptional<z.ZodString>;
-        ca_file: z.ZodOptional<z.ZodString>;
-        key_file: z.ZodOptional<z.ZodString>;
-        server_name: z.ZodOptional<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        tls_strategy?: "tls" | "mtls" | undefined;
-        cert_file?: string | undefined;
-        ca_file?: string | undefined;
-        key_file?: string | undefined;
-        server_name?: string | undefined;
-    }, {
-        tls_strategy?: "tls" | "mtls" | undefined;
-        cert_file?: string | undefined;
-        ca_file?: string | undefined;
-        key_file?: string | undefined;
-        server_name?: string | undefined;
-    }>;
-    host_port: z.ZodString;
-    log_level: z.ZodOptional<z.ZodEnum<["OFF", "DEBUG", "INFO", "WARN", "ERROR"]>>;
-}, "strip", z.ZodTypeAny, {
-    token: string;
-    tls_config: {
-        tls_strategy?: "tls" | "mtls" | undefined;
-        cert_file?: string | undefined;
-        ca_file?: string | undefined;
-        key_file?: string | undefined;
-        server_name?: string | undefined;
-    };
-    host_port: string;
-    log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
-}, {
-    token: string;
-    tls_config: {
-        tls_strategy?: "tls" | "mtls" | undefined;
-        cert_file?: string | undefined;
-        ca_file?: string | undefined;
-        key_file?: string | undefined;
-        server_name?: string | undefined;
-    };
-    host_port: string;
-    log_level?: "OFF" | "DEBUG" | "INFO" | "WARN" | "ERROR" | undefined;
-}>;
-export type ClientConfig = z.infer<typeof ClientConfigSchema> & {
-    credentials?: ChannelCredentials;
-};
-export type ClientTLSConfig = z.infer<typeof ClientTLSConfigSchema>;
-export {};

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

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClientConfigSchema = void 0;
-const zod_1 = require("zod");
-const ClientTLSConfigSchema = zod_1.z.object({
-    tls_strategy: zod_1.z.enum(['tls', 'mtls']).optional(),
-    cert_file: zod_1.z.string().optional(),
-    ca_file: zod_1.z.string().optional(),
-    key_file: zod_1.z.string().optional(),
-    server_name: zod_1.z.string().optional(),
-});
-exports.ClientConfigSchema = zod_1.z.object({
-    token: zod_1.z.string(),
-    tls_config: ClientTLSConfigSchema,
-    host_port: zod_1.z.string(),
-    log_level: zod_1.z.enum(['OFF', 'DEBUG', 'INFO', 'WARN', 'ERROR']).optional(),
-});

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

@@ -1,26 +0,0 @@
-import { EventClient } from '../event/event-client';
-import { DispatcherClient } from '../dispatcher/dispatcher-client';
-import { AdminClient } from '../admin/admin-client';
-import { Channel, ChannelCredentials } from 'nice-grpc';
-import { Workflow } from '@hatchet/workflow';
-import { Worker } from '../worker';
-import Logger from '@hatchet/util/logger/logger';
-import { ClientConfig } from './client-config';
-export interface HatchetClientOptions {
-    config_path?: string;
-    credentials?: ChannelCredentials;
-}
-export declare class HatchetClient {
-    config: ClientConfig;
-    credentials: ChannelCredentials;
-    channel: Channel;
-    event: EventClient;
-    dispatcher: DispatcherClient;
-    admin: AdminClient;
-    logger: Logger;
-    constructor(config?: Partial<ClientConfig>, options?: HatchetClientOptions);
-    static with_host_port(host: string, port: number, config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
-    static init(config?: Partial<ClientConfig>, options?: HatchetClientOptions): HatchetClient;
-    run(workflow: string | Workflow): Promise<Worker>;
-    worker(workflow: string | Workflow): Promise<Worker>;
-}

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

@@ -1,133 +0,0 @@
-"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());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HatchetClient = void 0;
-const zod_1 = require("zod");
-const config_loader_1 = require("../../util/config-loader");
-const event_client_1 = require("../event/event-client");
-const dispatcher_client_1 = require("../dispatcher/dispatcher-client");
-const admin_client_1 = require("../admin/admin-client");
-const nice_grpc_1 = require("nice-grpc");
-const worker_1 = require("../worker");
-const logger_1 = __importDefault(require("@hatchet/util/logger/logger"));
-const client_config_1 = require("./client-config");
-const addTokenMiddleware = (token) => function _(call, options) {
-    return __asyncGenerator(this, arguments, function* _1() {
-        var _a, e_1, _b, _c;
-        const optionsWithAuth = Object.assign(Object.assign({}, options), { metadata: new nice_grpc_1.Metadata({ authorization: `bearer ${token}` }) });
-        if (!call.responseStream) {
-            const response = yield __await(yield* __asyncDelegator(__asyncValues(call.next(call.request, optionsWithAuth))));
-            return yield __await(response);
-        }
-        try {
-            for (var _d = true, _e = __asyncValues(call.next(call.request, optionsWithAuth)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const response = _c;
-                yield yield __await(response);
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-        return yield __await(undefined);
-    });
-};
-class HatchetClient {
-    constructor(config, options) {
-        // 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({
-            path: options === null || options === void 0 ? void 0 : options.config_path,
-        });
-        try {
-            const valid = client_config_1.ClientConfigSchema.parse(Object.assign(Object.assign({}, loaded), Object.assign(Object.assign({}, config), { tls_config: Object.assign(Object.assign({}, loaded.tls_config), config === null || config === void 0 ? void 0 : config.tls_config) })));
-            this.config = valid;
-        }
-        catch (e) {
-            if (e instanceof zod_1.z.ZodError) {
-                throw new Error(`Invalid client config: ${e.message}`);
-            }
-            throw e;
-        }
-        this.credentials =
-            (_a = options === null || options === void 0 ? void 0 : options.credentials) !== null && _a !== void 0 ? _a : config_loader_1.ConfigLoader.createCredentials(this.config.tls_config);
-        this.channel = (0, nice_grpc_1.createChannel)(this.config.host_port, this.credentials, {
-            'grpc.ssl_target_name_override': this.config.tls_config.server_name,
-        });
-        const clientFactory = (0, nice_grpc_1.createClientFactory)().use(addTokenMiddleware(this.config.token));
-        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.logger = new logger_1.default('HatchetClient', this.config.log_level);
-        this.logger.info(`Initialized 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);
-    }
-    run(workflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const worker = yield this.worker(workflow);
-            worker.start();
-            return worker;
-        });
-    }
-    worker(workflow) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const name = typeof workflow === 'string' ? workflow : workflow.id;
-            const worker = new worker_1.Worker(this, {
-                name,
-            });
-            if (typeof workflow !== 'string') {
-                yield worker.register_workflow(workflow);
-                return worker;
-            }
-            return worker;
-        });
-    }
-}
-exports.HatchetClient = HatchetClient;

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

@@ -1,2 +0,0 @@
-export declare const mockChannel: import("nice-grpc").Channel;
-export declare const mockFactory: import("nice-grpc").ClientFactory<{}>;

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

@@ -1,135 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockFactory = exports.mockChannel = void 0;
-const nice_grpc_1 = require("nice-grpc");
-const hatchet_client_1 = require("./hatchet-client");
-exports.mockChannel = (0, nice_grpc_1.createChannel)('localhost:50051');
-exports.mockFactory = (0, nice_grpc_1.createClientFactory)();
-describe('Client', () => {
-    beforeEach(() => {
-        process.env.HATCHET_CLIENT_TOKEN = 'TOKEN_ENV';
-    });
-    it('should load from environment variables', () => {
-        const hatchet = new hatchet_client_1.HatchetClient({
-            token: 'TOKEN_ENV',
-            host_port: 'HOST_PORT',
-            log_level: 'OFF',
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, {
-            credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-        });
-        expect(hatchet.config).toEqual({
-            token: 'TOKEN_ENV',
-            host_port: 'HOST_PORT',
-            log_level: 'OFF',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        });
-    });
-    it('should throw an error if the config param is invalid', () => {
-        expect(() => new hatchet_client_1.HatchetClient({
-            host_port: 'HOST_PORT',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                // @ts-ignore
-                server_name: undefined,
-            },
-        })).toThrow();
-    });
-    it('should favor config param over yaml over env vars ', () => {
-        const hatchet = new hatchet_client_1.HatchetClient({
-            tls_config: {
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        }, {
-            config_path: './fixtures/.hatchet.yaml',
-            credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-        });
-        expect(hatchet.config).toEqual({
-            token: 'TOKEN_YAML',
-            host_port: 'HOST_PORT_YAML',
-            log_level: 'INFO',
-            tls_config: {
-                tls_strategy: 'tls',
-                cert_file: 'TLS_CERT_FILE',
-                key_file: 'TLS_KEY_FILE',
-                ca_file: 'TLS_ROOT_CA_FILE',
-                server_name: 'TLS_SERVER_NAME',
-            },
-        });
-    });
-    describe('with_host_port', () => {
-        it('should set the host_port', () => {
-            const hatchet = hatchet_client_1.HatchetClient.with_host_port('HOST', 1234, {
-                token: 'TOKEN',
-                tls_config: {
-                    tls_strategy: 'tls',
-                    cert_file: 'TLS_CERT_FILE',
-                    key_file: 'TLS_KEY_FILE',
-                    ca_file: 'TLS_ROOT_CA_FILE',
-                    server_name: 'TLS_SERVER_NAME',
-                },
-            }, {
-                credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-            });
-            expect(hatchet.config).toEqual({
-                token: 'TOKEN',
-                host_port: 'HOST:1234',
-                log_level: 'INFO',
-                tls_config: {
-                    tls_strategy: 'tls',
-                    cert_file: 'TLS_CERT_FILE',
-                    key_file: 'TLS_KEY_FILE',
-                    ca_file: 'TLS_ROOT_CA_FILE',
-                    server_name: 'TLS_SERVER_NAME',
-                },
-            });
-        });
-    });
-    describe('Worker', () => {
-        let hatchet;
-        beforeEach(() => {
-            hatchet = new hatchet_client_1.HatchetClient({
-                token: 'TOKEN',
-                host_port: 'HOST_PORT',
-                log_level: 'OFF',
-                tls_config: {
-                    cert_file: 'TLS_CERT_FILE',
-                    key_file: 'TLS_KEY_FILE',
-                    ca_file: 'TLS_ROOT_CA_FILE',
-                    server_name: 'TLS_SERVER_NAME',
-                },
-            }, {
-                credentials: nice_grpc_1.ChannelCredentials.createInsecure(),
-            });
-        });
-        describe('run', () => {
-            xit('should start a worker', () => {
-                const worker = hatchet.run('workflow1');
-                expect(worker).toBeDefined();
-            });
-        });
-        describe('worker', () => {
-            it('should start a worker', () => {
-                const worker = hatchet.worker('workflow1');
-                expect(worker).toBeDefined();
-            });
-        });
-    });
-});

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

@@ -1,2 +0,0 @@
-export * from './hatchet-client';
-export * from './client-config';