@abinnovision/nestjs-hatchet 0.1.0

package/dist/ref/refs.d.ts

@@ -0,0 +1,45 @@
+import type { ContextMethodKeys, TaskHostCtor, WorkflowHostCtor } from "./shared";
+/**
+ * Reference to a task within a {@link TaskHost}
+ */
+export interface TaskRef<C extends TaskHostCtor<any>, I, O> {
+    readonly host: C;
+    readonly method: ContextMethodKeys<InstanceType<C>>;
+    readonly __types: {
+        input: I;
+        output: O;
+    };
+}
+/**
+ * Reference to a workflow as a {@link WorkflowHost}
+ */
+export interface WorkflowRef<C extends WorkflowHostCtor<any>, I, O> {
+    readonly host: C;
+    readonly __types: {
+        input: I;
+        output: O;
+    };
+}
+/**
+ * Reference to a task within a {@link WorkflowHost}, without the knowledge of the {@link WorkflowHost} itself.
+ */
+export interface WorkflowTaskRef<I, O> {
+    readonly method: string;
+    readonly __types: {
+        input: I;
+        output: O;
+    };
+}
+/**
+ * Represents any callable reference.
+ * Note that externally only TaskRef and WorkflowRef are supported.
+ */
+export type AnyCallableRef = TaskRef<any, any, any> | WorkflowRef<any, any, any>;
+/**
+ * Extracts the input type of the callable reference.
+ */
+export type InputOfRef<R extends AnyCallableRef> = R extends TaskRef<any, infer I, any> ? I : R extends WorkflowRef<any, infer I, any> ? I : never;
+/**
+ * Extracts the output type of the callable reference.
+ */
+export type OutputOfRef<R extends AnyCallableRef> = R extends TaskRef<any, any, infer O> ? O : R extends WorkflowRef<any, any, infer O> ? O : never;

package/dist/ref/refs.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ref/shared.d.ts

@@ -0,0 +1,91 @@
+import type { TaskHost, WorkflowHost } from "../abstracts";
+import type { BaseCtx, TaskMarker } from "../context/context";
+/**
+ * Converts a union to an intersection. Used for detecting if a type is a union.
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+/**
+ * Checks if a type is a union (more than one member).
+ */
+type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
+/**
+ * Represents any host instance type.
+ */
+export type AnyHost = WorkflowHost<any> | TaskHost<any>;
+/**
+ * Represents any host constructor type.
+ */
+export type AnyHostCtor = WorkflowHostCtor<any> | TaskHostCtor<any>;
+/**
+ * Represents a workflow host constructor type.
+ */
+export type WorkflowHostCtor<I> = abstract new (...args: any[]) => WorkflowHost<I>;
+/**
+ * Represents a task host constructor type.
+ */
+export type TaskHostCtor<I> = abstract new (...args: any[]) => TaskHost<I>;
+export type IsTaskRunnableSignature<F extends (...args: any[]) => any, C extends BaseCtx<any> = any> = F extends (...args: any[]) => any ? Parameters<F> extends [infer CI, ...any[]] ? CI extends {
+    [K in TaskMarker]: true;
+} ? CI extends C ? true : false : false : false : false;
+/**
+ * Extracts the keys of any host that matches the "task"-runnable signature.
+ */
+export type ContextMethodKeys<T extends AnyHost, C extends BaseCtx<any> = any> = {
+    [K in keyof T]: T[K] extends (...args: any) => any ? IsTaskRunnableSignature<T[K], C> extends true ? K : never : never;
+}[keyof T];
+/**
+ * Extracts the input type of a method of a class which takes a context as the first argument.
+ */
+export type AnyTaskInput<T extends AnyHostCtor, M extends ContextMethodKeys<InstanceType<T>>> = InstanceType<T>[M] extends (...args: any) => any ? Parameters<InstanceType<T>[M]> extends [BaseCtx<infer I>, ...any[]] ? I : never : never;
+/**
+ * Extracts the output type of a method of a class which takes a context as the first argument.
+ */
+export type AnyTaskOutput<T extends AnyHostCtor, M extends ContextMethodKeys<InstanceType<T>>> = InstanceType<T>[M] extends (...args: any) => any ? Awaited<ReturnType<InstanceType<T>[M]>> : never;
+/**
+ * Extracts the input type of a workflow host.
+ */
+export type WorkflowInput<T extends WorkflowHostCtor<any>> = InstanceType<T> extends WorkflowHost<infer I> ? I : never;
+/**
+ * Extracts the output types of all the methods of a workflow host.
+ */
+export type WorkflowTasksOutputMap<C extends WorkflowHost<any>> = {
+    [K in ContextMethodKeys<C>]: C[K] extends (...a: any[]) => infer R ? Awaited<R> : never;
+};
+/**
+ * Extracts the output type of a workflow host.
+ */
+export type WorkflowOutput<T extends WorkflowHostCtor<any>> = WorkflowTasksOutputMap<InstanceType<T>>;
+export type AnyTaskFn<C extends BaseCtx<any>, O> = (ctx: C) => Promise<O> | O;
+export type OutputOfTaskFn<T extends AnyTaskFn<any, any>> = IsTaskRunnableSignature<T> extends true ? Awaited<ReturnType<T>> : never;
+/**
+ * Error type for invalid TaskHost - shows as a readable string literal in error messages.
+ */
+export type InvalidTaskHost<Reason extends string> = `Error: ${Reason}`;
+/**
+ * Error type for invalid WorkflowHost - shows as a readable string literal in error messages.
+ */
+export type InvalidWorkflowHost<Reason extends string> = `Error: ${Reason}`;
+/**
+ * Validates that a TaskHost has exactly one task method.
+ * Returns the host type if valid, or an error type with a descriptive message.
+ */
+export type ValidTaskHost<C extends TaskHostCtor<any>> = ContextMethodKeys<InstanceType<C>, BaseCtx<any>> extends infer K ? [K] extends [never] ? InvalidTaskHost<"TaskHost must have exactly one method with TaskCtx parameter"> : IsUnion<K> extends true ? InvalidTaskHost<"TaskHost has multiple task methods - only one is allowed"> : C : never;
+/**
+ * Validates that a WorkflowHost has at least one workflow task method.
+ * Returns the host type if valid, or an error type with a descriptive message.
+ */
+export type ValidWorkflowHost<C extends WorkflowHostCtor<any>> = ContextMethodKeys<InstanceType<C>, BaseCtx<any>> extends infer K ? [K] extends [never] ? InvalidWorkflowHost<"WorkflowHost must have at least one method with WorkflowCtx parameter"> : C : never;
+/**
+ * Extracts the single task method key from a TaskHost.
+ * Since a TaskHost must have exactly one task method, this resolves to that method's key.
+ */
+export type TaskMethodKey<T extends TaskHostCtor<any>> = ContextMethodKeys<InstanceType<T>, BaseCtx<any>>;
+/**
+ * Extracts the input type from the single task method of a TaskHost.
+ */
+export type TaskInput<T extends TaskHostCtor<any>> = AnyTaskInput<T, TaskMethodKey<T>>;
+/**
+ * Extracts the output type from the single task method of a TaskHost.
+ */
+export type TaskOutput<T extends TaskHostCtor<any>> = AnyTaskOutput<T, TaskMethodKey<T>>;
+export {};

package/dist/ref/shared.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/sdk/hatchet-client.factory.d.ts

@@ -0,0 +1,5 @@
+import type { FactoryProvider } from "@nestjs/common";
+/**
+ * Factory provider for the HatchetClient.
+ */
+export declare const hatchetClientFactory: FactoryProvider;

package/dist/sdk/hatchet-client.factory.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hatchetClientFactory = void 0;
+const typescript_sdk_1 = require("@hatchet-dev/typescript-sdk");
+const common_1 = require("@nestjs/common");
+const hatchet_module_config_1 = require("../hatchet.module-config");
+/**
+ * Creates a logger that matches the Hatchet logger interface based on the given context.
+ *
+ * @param loggingContext The context to log under.
+ */
+const loggerFactory = (loggingContext) => {
+    // Create a child logger for each context.
+    const logger = new common_1.Logger(`HatchetClient/${loggingContext}`);
+    /// Create a logger that matches the Hatchet logger interface.
+    return {
+        debug: (message, extra) => {
+            logger.debug(message, extra);
+        },
+        info: (message, extra) => {
+            logger.log(message, extra);
+        },
+        green: (message, extra) => {
+            logger.log(message, extra);
+        },
+        warn: (message, error, extra) => {
+            logger.warn(message, { ...extra, err: error });
+        },
+        error: (message, error, extra) => {
+            logger.error(message, { ...extra, err: error });
+        },
+    };
+};
+/**
+ * Factory provider for the HatchetClient.
+ */
+exports.hatchetClientFactory = {
+    provide: typescript_sdk_1.HatchetClient,
+    inject: [hatchet_module_config_1.hatchetModuleConfigToken],
+    useFactory: (opts) => {
+        return new typescript_sdk_1.HatchetClient({
+            ...opts.config,
+            logger: loggerFactory,
+        });
+    },
+};

package/dist/sdk/index.d.ts

@@ -0,0 +1 @@
+export * from "./hatchet-client.factory";

package/dist/sdk/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("./hatchet-client.factory"), exports);

package/package.json

@@ -0,0 +1,68 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@abinnovision/nestjs-hatchet",
+  "version": "0.1.0",
+  "keywords": [
+    "nestjs",
+    "hatchet"
+  ],
+  "repository": {
+    "url": "https://github.com/abinnovision/nestjs-commons"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "AB INNOVISION GmbH",
+    "email": "info@abinnovision.com",
+    "url": "https://abinnovision.com/"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "format:check": "prettier --check '{{src,test}/**/*,*}.{js,jsx,ts,tsx,json,json5,yml,yaml,md}'",
+    "format:fix": "prettier --write '{{src,test}/**/*,*}.{js,jsx,ts,tsx,json,json5,yml,yaml,md}'",
+    "lint:check": "eslint '{{src,test}/**/*,*}.{js,jsx,ts,tsx}'",
+    "lint:fix": "eslint '{{src,test}/**/*,*}.{js,jsx,ts,tsx}' --fix",
+    "test-unit": "vitest --run --coverage --config vitest.config.mts",
+    "test-unit:watch": "vitest --config vitest.config.mts"
+  },
+  "lint-staged": {
+    "src/**/*.{ts,js}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{js,ts,json,json5,yaml,yml,md}": [
+      "prettier --write"
+    ]
+  },
+  "prettier": "@abinnovision/prettier-config",
+  "dependencies": {
+    "@hatchet-dev/typescript-sdk": "^1.10.0",
+    "@standard-schema/spec": "^1.0.0",
+    "directed-graph-typed": "^2.1.0"
+  },
+  "devDependencies": {
+    "@abinnovision/eslint-config-base": "^3.0.2",
+    "@abinnovision/prettier-config": "^2.1.5",
+    "@swc/core": "^1.11.5",
+    "eslint": "^9.21.0",
+    "prettier": "^3.5.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15",
+    "vitest-mock-extended": "^3.1.0",
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/core": "^11.0.0"
+  }
+}