@abinnovision/nestjs-hatchet 0.2.2 → 0.3.0

package/dist/metadata/decorators/workflow-task.decorator.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTask = WorkflowTask;
+const keys_1 = require("../keys");
+/**
+ * Decorator to mark a method as a workflow task.
+ */
+function WorkflowTask(opts) {
+    return (_target, _propertyKey, descriptor) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        Reflect.defineMetadata(keys_1.METADATA_KEY_WORKFLOW_TASK_OPTS, opts, descriptor.value);
+        return descriptor;
+    };
+}

package/dist/metadata/index.d.ts

@@ -0,0 +1,6 @@
+export { Host } from "./decorators/host.decorator";
+export type { HostOpts } from "./decorators/host.decorator";
+export { Task } from "./decorators/task.decorator";
+export type { TaskOpts } from "./decorators/task.decorator";
+export { WorkflowTask } from "./decorators/workflow-task.decorator";
+export type { WorkflowTaskOpts } from "./decorators/workflow-task.decorator";

package/dist/metadata/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTask = exports.Task = exports.Host = void 0;
+// Decorators
+var host_decorator_1 = require("./decorators/host.decorator");
+Object.defineProperty(exports, "Host", { enumerable: true, get: function () { return host_decorator_1.Host; } });
+var task_decorator_1 = require("./decorators/task.decorator");
+Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return task_decorator_1.Task; } });
+var workflow_task_decorator_1 = require("./decorators/workflow-task.decorator");
+Object.defineProperty(exports, "WorkflowTask", { enumerable: true, get: function () { return workflow_task_decorator_1.WorkflowTask; } });

package/dist/metadata/keys.d.ts

@@ -0,0 +1,3 @@
+export declare const METADATA_KEY_HOST_OPTS = "hatchet:host:opts";
+export declare const METADATA_KEY_TASK_OPTS = "hatchet:task:opts";
+export declare const METADATA_KEY_WORKFLOW_TASK_OPTS = "hatchet:workflow:task:opts";

package/dist/metadata/keys.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_KEY_WORKFLOW_TASK_OPTS = exports.METADATA_KEY_TASK_OPTS = exports.METADATA_KEY_HOST_OPTS = void 0;
+exports.METADATA_KEY_HOST_OPTS = "hatchet:host:opts";
+exports.METADATA_KEY_TASK_OPTS = "hatchet:task:opts";
+exports.METADATA_KEY_WORKFLOW_TASK_OPTS = "hatchet:workflow:task:opts";

package/dist/metadata/translator.d.ts

@@ -0,0 +1,10 @@
+import type { HostOpts } from "./decorators";
+import type { CreateBaseWorkflowOpts } from "@hatchet-dev/typescript-sdk";
+/**
+ * SDK-compatible host options.
+ */
+export type SdkHostOpts = Omit<CreateBaseWorkflowOpts, "on">;
+/**
+ * Translates enhanced HostOpts to SDK-compatible SdkHostOpts.
+ */
+export declare const translateHostOpts: (opts: HostOpts) => SdkHostOpts;

package/dist/metadata/translator.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateHostOpts = void 0;
+/**
+ * Translates onEvents to SDK-compatible string array.
+ */
+const translateOnEvents = (onEvents) => {
+    // If no onEvents provided, return undefined
+    if (!onEvents || onEvents.length === 0) {
+        return undefined;
+    }
+    return onEvents.map((e) => (typeof e === "string" ? e : e.name));
+};
+/**
+ * Translates enhanced HostOpts to SDK-compatible SdkHostOpts.
+ */
+const translateHostOpts = (opts) => {
+    const { onEvents, ...passthrough } = opts;
+    const translatedOnEvents = translateOnEvents(onEvents);
+    // Only include onEvents if it has values
+    if (translatedOnEvents) {
+        return { ...passthrough, onEvents: translatedOnEvents };
+    }
+    return passthrough;
+};
+exports.translateHostOpts = translateHostOpts;

package/dist/ref/helpers.d.ts

@@ -17,6 +17,7 @@ export declare function workflowRef<C extends WorkflowHostCtor<any>>(host: Valid
 export declare function getRefAccessor(ref: AnyCallableRef): {
     readonly ctor: AnyHostCtor;
     get metadata(): import("..").HostOpts;
+    get sdkOpts(): import("../accessor").SdkHostOpts;
     get name(): string;
     get isWorkflow(): boolean;
     get isTask(): boolean;

package/dist/ref/index.d.ts

@@ -1,3 +1,3 @@
-export * from "./refs";
-export * from "./helpers";
-export * from "./shared";
+export type { TaskRef, WorkflowRef, AnyCallableRef, InputOfRef, OutputOfRef, } from "./refs";
+export { taskRef, workflowRef } from "./helpers";
+export type { TaskInput, TaskOutput, WorkflowInput, WorkflowOutput, WorkflowTasksOutputMap, } from "./shared";

package/dist/ref/index.js

@@ -1,19 +1,7 @@
 "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("./refs"), exports);
-__exportStar(require("./helpers"), exports);
-__exportStar(require("./shared"), exports);
+exports.workflowRef = exports.taskRef = void 0;
+// Public API - Factory functions
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "taskRef", { enumerable: true, get: function () { return helpers_1.taskRef; } });
+Object.defineProperty(exports, "workflowRef", { enumerable: true, get: function () { return helpers_1.workflowRef; } });

package/dist/ref/shared.d.ts

@@ -19,12 +19,14 @@ export type AnyHostCtor = WorkflowHostCtor<any> | TaskHostCtor<any>;
 /**
  * Represents a workflow host constructor type.
  *
+ * @internal Used in public signatures but not intended for direct external use.
  * @template I - The input type that the workflow accepts.
  */
 export type WorkflowHostCtor<I> = abstract new (...args: any[]) => WorkflowHost<I>;
 /**
  * Represents a task host constructor type.
  *
+ * @internal Used in public signatures but not intended for direct external use.
  * @template I - The input type that the task accepts.
  */
 export type TaskHostCtor<I> = abstract new (...args: any[]) => TaskHost<I>;
@@ -52,6 +54,7 @@ export type IsTaskRunnableSignature<F extends (...args: any[]) => any, C extends
  * For a TaskHost, this should return exactly one key.
  * For a WorkflowHost, this returns all workflow task method keys.
  *
+ * @internal Used by WorkflowTaskOpts but not intended for direct external use.
  * @template T - The host instance type.
  * @template C - Optional context type constraint.
  */
@@ -135,12 +138,14 @@ export type WorkflowOutput<T extends WorkflowHostCtor<any>> = WorkflowTasksOutpu
 /**
  * Error type for invalid TaskHost - shows as a readable string literal in error messages.
  *
+ * @internal Type-level error message, not intended for direct external use.
  * @template Reason - The error message to display.
  */
 export type InvalidTaskHost<Reason extends string> = `Error: ${Reason}`;
 /**
  * Error type for invalid WorkflowHost - shows as a readable string literal in error messages.
  *
+ * @internal Type-level error message, not intended for direct external use.
  * @template Reason - The error message to display.
  */
 export type InvalidWorkflowHost<Reason extends string> = `Error: ${Reason}`;
@@ -150,6 +155,7 @@ export type InvalidWorkflowHost<Reason extends string> = `Error: ${Reason}`;
  *
  * Used by {@link taskRef} to provide compile-time validation.
  *
+ * @internal Used in taskRef() signature but not intended for direct external use.
  * @template C - The task host constructor type to validate.
  */
 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;
@@ -159,6 +165,7 @@ export type ValidTaskHost<C extends TaskHostCtor<any>> = ContextMethodKeys<Insta
  *
  * Used by {@link workflowRef} to provide compile-time validation.
  *
+ * @internal Used in workflowRef() signature but not intended for direct external use.
  * @template C - The workflow host constructor type to validate.
  */
 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;

package/dist/references/helpers.d.ts

@@ -0,0 +1,27 @@
+import type { AnyCallableRef, TaskRef, WorkflowRef } from "./refs";
+import type { AnyHostCtor, TaskHostCtor, ValidTaskHost, ValidWorkflowHost, WorkflowHostCtor } from "./shared";
+/**
+ * Creates a reference to a task within a {@link TaskHost}.
+ * The task method is automatically resolved since a TaskHost has exactly one task.
+ * Compile-time validation ensures the host has exactly one task method.
+ */
+export declare function taskRef<C extends TaskHostCtor<any>>(host: ValidTaskHost<C>): TaskRef<C>;
+/**
+ * Creates a reference to a workflow as a {@link WorkflowHost}.
+ * Compile-time validation ensures the host has at least one workflow task method.
+ */
+export declare function workflowRef<C extends WorkflowHostCtor<any>>(host: ValidWorkflowHost<C>): WorkflowRef<C>;
+/**
+ * Gets the HostAccessor from a callable reference.
+ */
+export declare function getRefAccessor(ref: AnyCallableRef): {
+    readonly ctor: AnyHostCtor;
+    get metadata(): import("..").HostOpts;
+    get sdkOpts(): import("../metadata/translator").SdkHostOpts;
+    get name(): string;
+    get isWorkflow(): boolean;
+    get isTask(): boolean;
+    get methods(): string[];
+    getWorkflowTaskMeta(method: string): import("..").WorkflowTaskOpts<any>;
+    getTaskMeta(method: string): import("..").TaskOpts;
+};

package/dist/references/helpers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskRef = taskRef;
+exports.workflowRef = workflowRef;
+exports.getRefAccessor = getRefAccessor;
+const accessor_1 = require("../metadata/accessor");
+/**
+ * Creates a reference to a task within a {@link TaskHost}.
+ * The task method is automatically resolved since a TaskHost has exactly one task.
+ * Compile-time validation ensures the host has exactly one task method.
+ */
+function taskRef(host) {
+    const accessor = (0, accessor_1.fromCtor)(host);
+    return {
+        host,
+        method: accessor.methods[0],
+    };
+}
+/**
+ * Creates a reference to a workflow as a {@link WorkflowHost}.
+ * Compile-time validation ensures the host has at least one workflow task method.
+ */
+function workflowRef(host) {
+    return { host };
+}
+/**
+ * Gets the HostAccessor from a callable reference.
+ */
+function getRefAccessor(ref) {
+    return (0, accessor_1.fromCtor)(ref.host);
+}

package/dist/references/index.d.ts

@@ -0,0 +1,3 @@
+export type { TaskRef, WorkflowRef, AnyCallableRef, InputOfRef, OutputOfRef, } from "./refs";
+export { taskRef, workflowRef } from "./helpers";
+export type { TaskInput, TaskOutput, WorkflowInput, WorkflowOutput, WorkflowTasksOutputMap, } from "./shared";

package/dist/references/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workflowRef = exports.taskRef = void 0;
+// *Ref functions
+var helpers_1 = require("./helpers");
+Object.defineProperty(exports, "taskRef", { enumerable: true, get: function () { return helpers_1.taskRef; } });
+Object.defineProperty(exports, "workflowRef", { enumerable: true, get: function () { return helpers_1.workflowRef; } });

package/dist/references/refs.d.ts

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

package/dist/references/refs.js

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

package/dist/references/shared.d.ts

@@ -0,0 +1,172 @@
+import type { TaskHost, WorkflowHost } from "../abstracts";
+import type { BaseCtx, TaskMarker } from "../execution/context/types";
+/**
+ * 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.
+ *
+ * @internal Used in public signatures but not intended for direct external use.
+ * @template I - The input type that the workflow accepts.
+ */
+export type WorkflowHostCtor<I> = abstract new (...args: any[]) => WorkflowHost<I>;
+/**
+ * Represents a task host constructor type.
+ *
+ * @internal Used in public signatures but not intended for direct external use.
+ * @template I - The input type that the task accepts.
+ */
+export type TaskHostCtor<I> = abstract new (...args: any[]) => TaskHost<I>;
+/**
+ * Checks if a function signature is a "runnable" task method.
+ *
+ * A method is considered runnable if its first parameter is a context type
+ * that includes the TaskMarker brand. This distinguishes actual task methods
+ * (decorated with `@Task()` or `@WorkflowTask()`) from helper methods that
+ * use `HelperCtx` which lacks the marker.
+ *
+ * @template F - The function type to check.
+ * @template C - The expected context type (defaults to any BaseCtx).
+ * @returns `true` if F is a task method, `false` otherwise.
+ */
+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 method keys from a host that are "runnable" task methods.
+ *
+ * Uses {@link IsTaskRunnableSignature} to filter only methods whose first
+ * parameter has the TaskMarker brand (i.e., uses `TaskCtx` or `WorkflowCtx`).
+ *
+ * For a TaskHost, this should return exactly one key.
+ * For a WorkflowHost, this returns all workflow task method keys.
+ *
+ * @internal Used by WorkflowTaskOpts but not intended for direct external use.
+ * @template T - The host instance type.
+ * @template C - Optional context type constraint.
+ */
+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 output (return) type of a specific task method.
+ *
+ * @template T - The host constructor type.
+ * @template M - The method key (must be a valid task method key).
+ * @returns The awaited return type of the method.
+ */
+export type AnyTaskOutput<T extends AnyHostCtor, M extends ContextMethodKeys<InstanceType<T>>> = InstanceType<T>[M] extends (...args: any) => any ? Awaited<ReturnType<InstanceType<T>[M]>> : never;
+/**
+ * Represents any task function signature.
+ *
+ * A task function takes a context as its first parameter and returns
+ * a value (sync or async).
+ *
+ * @template C - The context type.
+ * @template O - The output type.
+ */
+export type AnyTaskFn<C extends BaseCtx<any>, O> = (ctx: C) => Promise<O> | O;
+/**
+ * Extracts the output type from a task function, but only if it's a valid
+ * task method (has TaskMarker in its context parameter).
+ *
+ * Returns `never` for helper methods that use `HelperCtx`.
+ * This is used by the `parent()` method in workflows to get type-safe
+ * access to parent task outputs.
+ *
+ * @template T - The task function type.
+ */
+export type OutputOfTaskFn<T extends AnyTaskFn<any, any>> = IsTaskRunnableSignature<T> extends true ? Awaited<ReturnType<T>> : 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.
+ *
+ * @template T - The task host constructor type.
+ */
+export type TaskMethodKey<T extends TaskHostCtor<any>> = ContextMethodKeys<InstanceType<T>, BaseCtx<any>>;
+/**
+ * Extracts the input type from a TaskHost.
+ *
+ * @template T - The task host constructor type.
+ */
+export type TaskInput<T extends TaskHostCtor<any>> = InstanceType<T> extends TaskHost<infer I> ? I : never;
+/**
+ * Extracts the output type from the single task method of a TaskHost.
+ *
+ * @template T - The task host constructor type.
+ */
+export type TaskOutput<T extends TaskHostCtor<any>> = AnyTaskOutput<T, TaskMethodKey<T>>;
+/**
+ * Extracts the input type from a WorkflowHost constructor.
+ *
+ * @template T - The workflow host constructor type.
+ */
+export type WorkflowInput<T extends WorkflowHostCtor<any>> = InstanceType<T> extends WorkflowHost<infer I> ? I : never;
+/**
+ * Maps each workflow task method to its output type.
+ *
+ * @template C - The workflow host instance type.
+ * @example
+ * ```ts
+ * // For a workflow with step1() returning { a: string } and step2() returning { b: number }
+ * type Output = WorkflowTasksOutputMap<MyWorkflow>;
+ * // Result: { step1: { a: string }; step2: { b: number } }
+ * ```
+ */
+export type WorkflowTasksOutputMap<C extends WorkflowHost<any>> = {
+    [K in ContextMethodKeys<C>]: C[K] extends (...a: any[]) => infer R ? Awaited<R> : never;
+};
+/**
+ * Extracts the complete output type of a workflow (map of all task outputs).
+ *
+ * @template T - The workflow host constructor type.
+ */
+export type WorkflowOutput<T extends WorkflowHostCtor<any>> = WorkflowTasksOutputMap<InstanceType<T>>;
+/**
+ * Error type for invalid TaskHost - shows as a readable string literal in error messages.
+ *
+ * @internal Type-level error message, not intended for direct external use.
+ * @template Reason - The error message to display.
+ */
+export type InvalidTaskHost<Reason extends string> = `Error: ${Reason}`;
+/**
+ * Error type for invalid WorkflowHost - shows as a readable string literal in error messages.
+ *
+ * @internal Type-level error message, not intended for direct external use.
+ * @template Reason - The error message to display.
+ */
+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.
+ *
+ * Used by {@link taskRef} to provide compile-time validation.
+ *
+ * @internal Used in taskRef() signature but not intended for direct external use.
+ * @template C - The task host constructor type to validate.
+ */
+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.
+ *
+ * Used by {@link workflowRef} to provide compile-time validation.
+ *
+ * @internal Used in workflowRef() signature but not intended for direct external use.
+ * @template C - The workflow host constructor type to validate.
+ */
+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;
+export {};

package/dist/references/shared.js

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

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

@@ -37,10 +37,8 @@ const loggerFactory = (loggingContext) => {
 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,
-        });
-    },
+    useFactory: (opts) => new typescript_sdk_1.HatchetClient({
+        ...opts.config,
+        logger: loggerFactory,
+    }),
 };

package/package.json

@@ -1,14 +1,15 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@abinnovision/nestjs-hatchet",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "keywords": [
     "nestjs",
     "hatchet"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/abinnovision/nestjs-commons"
+    "url": "https://github.com/abinnovision/nestjs-commons.git",
+    "directory": "packages/hatchet"
   },
   "license": "Apache-2.0",
   "author": {
@@ -19,11 +20,14 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.js"
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENSE",
+    "README.md"
   ],
   "scripts": {
     "build": "tsc --project tsconfig.build.json",