@hatchet-dev/typescript-sdk 0.1.1 → 0.1.2

package/sdk.d.ts

@@ -0,0 +1,2 @@
+import { HatchetClient as Hatchet } from '../../src/clients/hatchet-client';
+export default Hatchet;

package/sdk.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hatchet_client_1 = require("../../src/clients/hatchet-client");
+exports.default = hatchet_client_1.HatchetClient;

package/step.d.ts

@@ -0,0 +1,33 @@
+import * as z from 'zod';
+export declare const CreateStepSchema: z.ZodObject<{
+    name: z.ZodString;
+    parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeout: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    parents?: string[] | undefined;
+    timeout?: string | undefined;
+}, {
+    name: string;
+    parents?: string[] | undefined;
+    timeout?: string | undefined;
+}>;
+export type NextStep = {
+    [key: string]: string;
+};
+interface ContextData<T = unknown> {
+    input: T;
+    parents: Record<string, any>;
+    triggered_by_event: string;
+}
+export declare class Context<T = unknown> {
+    data: ContextData<T>;
+    constructor(payload: string);
+    stepOutput(step: string): string;
+    triggeredByEvent(): boolean;
+    workflowInput(): any;
+}
+export interface CreateStep<T> extends z.infer<typeof CreateStepSchema> {
+    run: (ctx: Context) => Promise<NextStep> | NextStep | void;
+}
+export {};

package/step.js

@@ -0,0 +1,65 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = exports.CreateStepSchema = void 0;
+const hatchet_error_1 = __importDefault(require("../../src/util/errors/hatchet-error"));
+const z = __importStar(require("zod"));
+const workflow_1 = require("./workflow");
+exports.CreateStepSchema = z.object({
+    name: z.string(),
+    parents: z.array(z.string()).optional(),
+    timeout: workflow_1.HatchetTimeoutSchema.optional(),
+});
+class Context {
+    constructor(payload) {
+        try {
+            this.data = JSON.parse(JSON.parse(payload));
+        }
+        catch (e) {
+            throw new hatchet_error_1.default(`Could not parse payload: ${e.message}`);
+        }
+    }
+    stepOutput(step) {
+        if (!this.data.parents) {
+            throw new hatchet_error_1.default('Step output not found');
+        }
+        if (!this.data.parents[step]) {
+            throw new hatchet_error_1.default(`Step output for '${step}' not found`);
+        }
+        return this.data.parents[step];
+    }
+    triggeredByEvent() {
+        var _a;
+        return ((_a = this.data) === null || _a === void 0 ? void 0 : _a.triggered_by_event) === 'event';
+    }
+    workflowInput() {
+        var _a;
+        return ((_a = this.data) === null || _a === void 0 ? void 0 : _a.input) || {};
+    }
+}
+exports.Context = Context;

package/util/config-loader/config-loader.d.ts

@@ -0,0 +1,13 @@
+import { ClientConfig } from '../../../../src/clients/hatchet-client';
+import { ChannelCredentials } from 'nice-grpc';
+interface LoadClientConfigOptions {
+    path?: string;
+}
+export declare class ConfigLoader {
+    static load_client_config(config?: LoadClientConfigOptions): Partial<ClientConfig>;
+    static get default_yaml_config_path(): string;
+    static createCredentials(config: ClientConfig['tls_config']): ChannelCredentials;
+    static load_yaml_config(path?: string): ClientConfig | undefined;
+    private static env;
+}
+export {};

package/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("../../../../src/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/util/config-loader/index.d.ts

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

package/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/util/errors/hatchet-error.d.ts

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

package/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/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/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/util/logger/index.d.ts

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

package/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/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/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/util/sleep.d.ts

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

package/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/workflow.d.ts

@@ -0,0 +1,111 @@
+import * as z from 'zod';
+import { CreateStep } from './step';
+import { ConcurrencyLimitStrategy as PbConcurrencyLimitStrategy } from './protoc/workflows';
+declare const StepsSchema: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    parents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    timeout: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    parents?: string[] | undefined;
+    timeout?: string | undefined;
+}, {
+    name: string;
+    parents?: string[] | undefined;
+    timeout?: string | undefined;
+}>, "many">;
+export type Steps = z.infer<typeof StepsSchema>;
+export declare const ConcurrencyLimitStrategy: typeof PbConcurrencyLimitStrategy;
+export declare const WorkflowConcurrency: z.ZodObject<{
+    action: z.ZodOptional<z.ZodString>;
+    maxRuns: z.ZodOptional<z.ZodNumber>;
+    limitStrategy: z.ZodOptional<z.ZodNativeEnum<typeof PbConcurrencyLimitStrategy>>;
+}, "strip", z.ZodTypeAny, {
+    action?: string | undefined;
+    maxRuns?: number | undefined;
+    limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+}, {
+    action?: string | undefined;
+    maxRuns?: number | undefined;
+    limitStrategy?: PbConcurrencyLimitStrategy | undefined;
+}>;
+export declare const HatchetTimeoutSchema: z.ZodString;
+export declare const CreateWorkflowSchema: z.ZodObject<{
+    id: z.ZodString;
+    description: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    timeout: z.ZodOptional<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">>;
+        timeout: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        parents?: string[] | undefined;
+        timeout?: string | undefined;
+    }, {
+        name: string;
+        parents?: string[] | undefined;
+        timeout?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    description: string;
+    steps: {
+        name: string;
+        parents?: string[] | undefined;
+        timeout?: string | undefined;
+    }[];
+    id: string;
+    on: {
+        cron: string;
+        event?: undefined;
+    } | {
+        event: string;
+        cron?: undefined;
+    };
+    version?: string | undefined;
+    timeout?: string | undefined;
+}, {
+    description: string;
+    steps: {
+        name: string;
+        parents?: string[] | undefined;
+        timeout?: string | undefined;
+    }[];
+    id: string;
+    on: {
+        cron: string;
+        event?: undefined;
+    } | {
+        event: string;
+        cron?: undefined;
+    };
+    version?: string | undefined;
+    timeout?: string | undefined;
+}>;
+export interface Workflow extends z.infer<typeof CreateWorkflowSchema> {
+    concurrency?: z.infer<typeof WorkflowConcurrency> & {
+        key: (ctx: any) => string;
+    };
+    steps: CreateStep<any>[];
+}
+export {};

package/workflow.js

@@ -0,0 +1,54 @@
+"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 = exports.HatchetTimeoutSchema = exports.WorkflowConcurrency = exports.ConcurrencyLimitStrategy = void 0;
+const z = __importStar(require("zod"));
+const step_1 = require("./step");
+const workflows_1 = require("./protoc/workflows");
+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.ConcurrencyLimitStrategy = workflows_1.ConcurrencyLimitStrategy;
+exports.WorkflowConcurrency = z.object({
+    action: z.string().optional(),
+    maxRuns: z.number().optional(),
+    limitStrategy: z.nativeEnum(exports.ConcurrencyLimitStrategy).optional(),
+});
+exports.HatchetTimeoutSchema = z.string();
+exports.CreateWorkflowSchema = z.object({
+    id: z.string(),
+    description: z.string(),
+    version: z.string().optional(),
+    timeout: exports.HatchetTimeoutSchema.optional(),
+    on: OnConfigSchema,
+    steps: StepsSchema,
+});