@hatchet-dev/typescript-sdk 0.0.1

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

@@ -0,0 +1,85 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigLoader = void 0;
+const yaml_1 = require("yaml");
+const fs_1 = require("fs");
+const p = __importStar(require("path"));
+const zod_1 = require("zod");
+const hatchet_client_1 = require("@clients/hatchet-client");
+const nice_grpc_1 = require("nice-grpc");
+const DEFAULT_CONFIG_FILE = '.hatchet.yaml';
+class ConfigLoader {
+    static load_client_config(config) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        const yaml = this.load_yaml_config(config === null || config === void 0 ? void 0 : config.path);
+        const tlsConfig = {
+            tls_strategy: (_c = (_b = (_a = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _a === void 0 ? void 0 : _a.tls_strategy) !== null && _b !== void 0 ? _b : this.env('HATCHET_CLIENT_TLS_STRATEGY')) !== null && _c !== void 0 ? _c : 'tls',
+            cert_file: (_e = (_d = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _d === void 0 ? void 0 : _d.cert_file) !== null && _e !== void 0 ? _e : this.env('HATCHET_CLIENT_TLS_CERT_FILE'),
+            key_file: (_g = (_f = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _f === void 0 ? void 0 : _f.key_file) !== null && _g !== void 0 ? _g : this.env('HATCHET_CLIENT_TLS_KEY_FILE'),
+            ca_file: (_j = (_h = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _h === void 0 ? void 0 : _h.ca_file) !== null && _j !== void 0 ? _j : this.env('HATCHET_CLIENT_TLS_ROOT_CA_FILE'),
+            server_name: (_l = (_k = yaml === null || yaml === void 0 ? void 0 : yaml.tls_config) === null || _k === void 0 ? void 0 : _k.server_name) !== null && _l !== void 0 ? _l : this.env('HATCHET_CLIENT_TLS_SERVER_NAME'),
+        };
+        return {
+            token: (_m = yaml === null || yaml === void 0 ? void 0 : yaml.token) !== null && _m !== void 0 ? _m : this.env('HATCHET_CLIENT_TOKEN'),
+            host_port: (_o = yaml === null || yaml === void 0 ? void 0 : yaml.host_port) !== null && _o !== void 0 ? _o : this.env('HATCHET_CLIENT_HOST_PORT'),
+            tls_config: tlsConfig,
+            log_level: (_q = (_p = yaml === null || yaml === void 0 ? void 0 : yaml.log_level) !== null && _p !== void 0 ? _p : this.env('HATCHET_CLIENT_LOG_LEVEL')) !== null && _q !== void 0 ? _q : 'INFO',
+        };
+    }
+    static get default_yaml_config_path() {
+        return p.join(process.cwd(), DEFAULT_CONFIG_FILE);
+    }
+    static createCredentials(config) {
+        if (config.tls_strategy === 'tls') {
+            const rootCerts = config.ca_file ? (0, fs_1.readFileSync)(config.ca_file) : undefined;
+            return nice_grpc_1.ChannelCredentials.createSsl(rootCerts);
+        }
+        const rootCerts = config.ca_file ? (0, fs_1.readFileSync)(config.ca_file) : null;
+        const privateKey = config.key_file ? (0, fs_1.readFileSync)(config.key_file) : null;
+        const certChain = config.cert_file ? (0, fs_1.readFileSync)(config.cert_file) : null;
+        return nice_grpc_1.ChannelCredentials.createSsl(rootCerts, privateKey, certChain);
+    }
+    static load_yaml_config(path) {
+        try {
+            const configFile = (0, fs_1.readFileSync)(p.join(__dirname, path !== null && path !== void 0 ? path : this.default_yaml_config_path), 'utf8');
+            const config = (0, yaml_1.parse)(configFile);
+            hatchet_client_1.ClientConfigSchema.partial().parse(config);
+            return config;
+        }
+        catch (e) {
+            if (!path)
+                return undefined;
+            if (e instanceof zod_1.z.ZodError) {
+                throw new Error(`Invalid yaml config: ${e.message}`);
+            }
+            throw e;
+        }
+    }
+    static env(name) {
+        return process.env[name];
+    }
+}
+exports.ConfigLoader = ConfigLoader;

package/dist/hatchet/util/config-loader/config-loader.test.d.ts

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

package/dist/hatchet/util/config-loader/config-loader.test.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_loader_1 = require("./config-loader");
+fdescribe('ConfigLoader', () => {
+    beforeEach(() => {
+        process.env.HATCHET_CLIENT_HOST_PORT = 'HOST_PORT';
+        process.env.HATCHET_CLIENT_TLS_CERT_FILE = 'TLS_CERT_FILE';
+        process.env.HATCHET_CLIENT_TLS_KEY_FILE = 'TLS_KEY_FILE';
+        process.env.HATCHET_CLIENT_TLS_ROOT_CA_FILE = 'TLS_ROOT_CA_FILE';
+        process.env.HATCHET_CLIENT_TLS_SERVER_NAME = 'TLS_SERVER_NAME';
+    });
+    it('should load from environment variables', () => {
+        const config = config_loader_1.ConfigLoader.load_client_config();
+        expect(config).toEqual({
+            host_port: 'HOST_PORT',
+            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',
+            },
+        });
+    });
+    it('should throw an error if the file is not found', () => {
+        expect(() => config_loader_1.ConfigLoader.load_client_config({
+            path: './fixtures/not-found.yaml',
+        })).toThrow();
+    });
+    xit('should throw an error if the yaml file fails validation', () => {
+        expect(() => 
+        // This test is failing because there is no invalid state of the yaml file, need to update with tls and mtls settings
+        config_loader_1.ConfigLoader.load_client_config({
+            path: './fixtures/.hatchet-invalid.yaml',
+        })).toThrow();
+    });
+    it('should favor yaml config over env vars', () => {
+        const config = config_loader_1.ConfigLoader.load_client_config({
+            path: './fixtures/.hatchet.yaml',
+        });
+        expect(config).toEqual({
+            token: 'TOKEN_YAML',
+            host_port: 'HOST_PORT_YAML',
+            log_level: 'INFO',
+            tls_config: {
+                tls_strategy: 'tls',
+                cert_file: 'TLS_CERT_FILE_YAML',
+                key_file: 'TLS_KEY_FILE_YAML',
+                ca_file: 'TLS_ROOT_CA_FILE_YAML',
+                server_name: 'TLS_SERVER_NAME_YAML',
+            },
+        });
+    });
+    xit('should attempt to load the root .hatchet.yaml config', () => {
+        //  i'm not sure the best way to test this, maybe spy on readFileSync called with
+        const config = config_loader_1.ConfigLoader.load_client_config({
+            path: './fixtures/.hatchet.yaml',
+        });
+        expect(config).toEqual({
+            token: 'TOKEN_YAML',
+            host_port: 'HOST_PORT_YAML',
+            tls_config: {
+                tls_strategy: 'tls',
+                cert_file: 'TLS_CERT_FILE_YAML',
+                key_file: 'TLS_KEY_FILE_YAML',
+                ca_file: 'TLS_ROOT_CA_FILE_YAML',
+                server_name: 'TLS_SERVER_NAME_YAML',
+            },
+        });
+    });
+});

package/dist/hatchet/util/config-loader/index.d.ts

@@ -0,0 +1 @@
+export * from './config-loader';

package/dist/hatchet/util/config-loader/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("./config-loader"), exports);

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

@@ -0,0 +1,4 @@
+declare class HatchetError extends Error {
+    constructor(message: string);
+}
+export default HatchetError;

package/dist/hatchet/util/errors/hatchet-error.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HatchetError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'HatchetError';
+    }
+}
+exports.default = HatchetError;

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

@@ -0,0 +1,6 @@
+declare class HatchetPromise<T> {
+    cancel: Function;
+    promise: Promise<T>;
+    constructor(promise: Promise<T>);
+}
+export default HatchetPromise;

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class HatchetPromise {
+    constructor(promise) {
+        this.cancel = (reason) => { };
+        this.promise = new Promise((resolve, reject) => {
+            this.cancel = reject;
+            Promise.resolve(promise).then(resolve).catch(reject);
+        });
+    }
+}
+exports.default = HatchetPromise;

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

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

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

@@ -0,0 +1,40 @@
+"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 });
+const hatchet_promise_1 = __importDefault(require("./hatchet-promise"));
+describe('HatchetPromise', () => {
+    it('should resolve the original promise if not canceled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const hatchetPromise = new hatchet_promise_1.default(new Promise((resolve) => {
+            setTimeout(() => resolve('RESOLVED'), 500);
+        }));
+        const result = yield hatchetPromise.promise;
+        expect(result).toEqual('RESOLVED');
+    }));
+    it('should resolve the cancel promise if canceled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const hatchetPromise = new hatchet_promise_1.default(new Promise((resolve) => {
+            setTimeout(() => resolve('RESOLVED'), 500);
+        }));
+        const result = hatchetPromise.promise;
+        setTimeout(() => {
+            hatchetPromise.cancel();
+        }, 100);
+        try {
+            yield result;
+            expect(true).toEqual(false); // this should not be reached
+        }
+        catch (e) {
+            expect(e).toEqual(undefined);
+        }
+    }));
+});

package/dist/hatchet/util/logger/index.d.ts

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

package/dist/hatchet/util/logger/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("./logger"), exports);

package/dist/hatchet/util/logger/logger.d.ts

@@ -0,0 +1,12 @@
+export type LogLevel = 'OFF' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export declare class Logger {
+    private logLevel;
+    private context;
+    constructor(context: string, logLevel?: LogLevel);
+    private log;
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}
+export default Logger;

package/dist/hatchet/util/logger/logger.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+// eslint-disable-next-line no-shadow
+var LogLevelEnum;
+(function (LogLevelEnum) {
+    LogLevelEnum[LogLevelEnum["OFF"] = -1] = "OFF";
+    LogLevelEnum[LogLevelEnum["DEBUG"] = 0] = "DEBUG";
+    LogLevelEnum[LogLevelEnum["INFO"] = 1] = "INFO";
+    LogLevelEnum[LogLevelEnum["WARN"] = 2] = "WARN";
+    LogLevelEnum[LogLevelEnum["ERROR"] = 3] = "ERROR";
+})(LogLevelEnum || (LogLevelEnum = {}));
+class Logger {
+    constructor(context, logLevel = 'INFO') {
+        this.logLevel = logLevel;
+        this.context = context;
+    }
+    log(level, message) {
+        if (LogLevelEnum[level] >= LogLevelEnum[this.logLevel]) {
+            console.log(`🪓 [${level}/${this.context}] ${message}`);
+        }
+    }
+    debug(message) {
+        this.log('DEBUG', message);
+    }
+    info(message) {
+        this.log('INFO', message);
+    }
+    warn(message) {
+        this.log('WARN', message);
+    }
+    error(message) {
+        this.log('ERROR', message);
+    }
+}
+exports.Logger = Logger;
+exports.default = Logger;

package/dist/hatchet/util/sleep.d.ts

@@ -0,0 +1,2 @@
+declare const sleep: (ms: number) => Promise<unknown>;
+export default sleep;

package/dist/hatchet/util/sleep.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.default = sleep;

package/dist/hatchet/workflow.d.ts

@@ -0,0 +1,78 @@
+import * as z from 'zod';
+import { CreateStep } from './step';
+declare const StepsSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    parents?: string[] | undefined;
+}, {
+    name: string;
+    parents?: string[] | undefined;
+}>, "many">;
+export type Steps = z.infer<typeof StepsSchema>;
+export declare const CreateWorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    on: z.ZodUnion<[z.ZodObject<{
+        cron: z.ZodString;
+        event: z.ZodUndefined;
+    }, "strip", z.ZodTypeAny, {
+        cron: string;
+        event?: undefined;
+    }, {
+        cron: string;
+        event?: undefined;
+    }>, z.ZodObject<{
+        cron: z.ZodUndefined;
+        event: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        event: string;
+        cron?: undefined;
+    }, {
+        event: string;
+        cron?: undefined;
+    }>]>;
+    steps: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        parents?: string[] | undefined;
+    }, {
+        name: string;
+        parents?: string[] | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    steps: {
+        name: string;
+        parents?: string[] | undefined;
+    }[];
+    id: string;
+    on: {
+        cron: string;
+        event?: undefined;
+    } | {
+        event: string;
+        cron?: undefined;
+    };
+}, {
+    description: string;
+    steps: {
+        name: string;
+        parents?: string[] | undefined;
+    }[];
+    id: string;
+    on: {
+        cron: string;
+        event?: undefined;
+    } | {
+        event: string;
+        cron?: undefined;
+    };
+}>;
+export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {
+    steps: CreateStep<any>[];
+}
+export {};

package/dist/hatchet/workflow.js

@@ -0,0 +1,44 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateWorkflowSchema = void 0;
+const z = __importStar(require("zod"));
+const step_1 = require("./step");
+const CronConfigSchema = z.object({
+    cron: z.string(),
+    event: z.undefined(),
+});
+const EventConfigSchema = z.object({
+    cron: z.undefined(),
+    event: z.string(),
+});
+const OnConfigSchema = z.union([CronConfigSchema, EventConfigSchema]);
+const StepsSchema = z.array(step_1.CreateStepSchema);
+exports.CreateWorkflowSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    on: OnConfigSchema,
+    steps: StepsSchema,
+});