@hatchet-dev/typescript-sdk 0.20.3 → 1.0.0-alpha0

package/v1/examples/concurrency-rr/run.js

@@ -0,0 +1,39 @@
+"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 workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.simpleConcurrency.run([
+            {
+                Message: 'Hello World',
+                GroupKey: 'A',
+            },
+            {
+                Message: 'Goodbye Moon',
+                GroupKey: 'A',
+            },
+            {
+                Message: 'Hello World B',
+                GroupKey: 'B',
+            },
+        ]);
+        // eslint-disable-next-line no-console
+        console.log(res[0]['to-lower'].TransformedMessage);
+        // eslint-disable-next-line no-console
+        console.log(res[1]['to-lower'].TransformedMessage);
+        // eslint-disable-next-line no-console
+        console.log(res[2]['to-lower'].TransformedMessage);
+    });
+}
+if (require.main === module) {
+    main().then(() => process.exit(0));
+}

package/v1/examples/concurrency-rr/worker.d.ts

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

package/v1/examples/concurrency-rr/worker.js

@@ -0,0 +1,24 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('simple-concurrency-worker', {
+            workflows: [workflow_1.simpleConcurrency],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/concurrency-rr/workflow.d.ts

@@ -0,0 +1,11 @@
+type SimpleInput = {
+    Message: string;
+    GroupKey: string;
+};
+type SimpleOutput = {
+    'to-lower': {
+        TransformedMessage: string;
+    };
+};
+export declare const simpleConcurrency: import("../../workflow").Workflow<SimpleInput, SimpleOutput>;
+export {};

package/v1/examples/concurrency-rr/workflow.js

@@ -0,0 +1,35 @@
+"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 });
+exports.simpleConcurrency = void 0;
+const workflow_1 = require("../../../workflow");
+const client_1 = require("../client");
+const sleep = (ms) => new Promise((resolve) => {
+    setTimeout(resolve, ms);
+});
+exports.simpleConcurrency = client_1.hatchet.workflow({
+    name: 'simple-concurrency',
+    concurrency: {
+        name: 'simple-concurrency',
+        maxRuns: 100,
+        limitStrategy: workflow_1.ConcurrencyLimitStrategy.GROUP_ROUND_ROBIN,
+        expression: 'input.GroupKey',
+    },
+});
+exports.simpleConcurrency.task({
+    name: 'to-lower',
+    fn: (input) => __awaiter(void 0, void 0, void 0, function* () {
+        yield sleep(Math.floor(Math.random() * (1000 - 200 + 1)) + 200);
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    }),
+});

package/v1/examples/dag/run.d.ts

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

package/v1/examples/dag/run.js

@@ -0,0 +1,24 @@
+"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 workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.dag.run({
+            Message: 'hello world',
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.reverse.Transformed);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/dag/worker.d.ts

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

package/v1/examples/dag/worker.js

@@ -0,0 +1,24 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('dag-worker', {
+            workflows: [workflow_1.dag],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/dag/workflow.d.ts

@@ -0,0 +1,11 @@
+type DagInput = {
+    Message: string;
+};
+type DagOutput = {
+    reverse: {
+        Original: string;
+        Transformed: string;
+    };
+};
+export declare const dag: import("../../workflow").Workflow<DagInput, DagOutput>;
+export {};

package/v1/examples/dag/workflow.js

@@ -0,0 +1,35 @@
+"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 });
+exports.dag = void 0;
+const client_1 = require("../client");
+exports.dag = client_1.hatchet.workflow({
+    name: 'simple',
+});
+const toLower = exports.dag.task({
+    name: 'to-lower',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+exports.dag.task({
+    name: 'reverse',
+    parents: [toLower],
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const lower = yield ctx.parentData(toLower);
+        return {
+            Original: input.Message,
+            Transformed: lower.TransformedMessage.split('').reverse().join(''),
+        };
+    }),
+});

package/v1/examples/deep/run.d.ts

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

package/v1/examples/deep/run.js

@@ -0,0 +1,28 @@
+"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 workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield workflow_1.parent.run({
+            Message: 'hello',
+            N: 5,
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.parent.Sum);
+    });
+}
+if (require.main === module) {
+    main()
+        // eslint-disable-next-line no-console
+        .catch(console.error)
+        .finally(() => process.exit(0));
+}

package/v1/examples/deep/worker.d.ts

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

package/v1/examples/deep/worker.js

@@ -0,0 +1,25 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('simple-worker', {
+            workflows: [workflow_1.parent, workflow_1.child1, workflow_1.child2, workflow_1.child3, workflow_1.child4, workflow_1.child5],
+            slots: 5000,
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/deep/workflow.d.ts

@@ -0,0 +1,18 @@
+type SimpleInput = {
+    Message: string;
+    N: number;
+};
+type Output = {
+    transformer: {
+        Sum: number;
+    };
+};
+export declare const child1: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child2: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child3: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child4: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const child5: import("../../workflow").Workflow<SimpleInput, Output>;
+export declare const parent: import("../../workflow").Workflow<SimpleInput, {
+    parent: Output["transformer"];
+}>;
+export {};

package/v1/examples/deep/workflow.js

@@ -0,0 +1,110 @@
+"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.parent = exports.child5 = exports.child4 = exports.child3 = exports.child2 = exports.child1 = void 0;
+const sleep_1 = __importDefault(require("../../../util/sleep"));
+const client_1 = require("../client");
+exports.child1 = client_1.hatchet.workflow({
+    name: 'child1',
+});
+exports.child1.task({
+    name: 'transformer',
+    fn: () => {
+        (0, sleep_1.default)(15);
+        return {
+            Sum: 1,
+        };
+    },
+});
+exports.child2 = client_1.hatchet.workflow({
+    name: 'child2',
+});
+exports.child2.task({
+    name: 'transformer',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const count = input.N;
+        const promises = Array(count)
+            .fill(null)
+            .map(() => ({ workflow: exports.child1, input }));
+        const results = yield ctx.bulkRunChildren(promises);
+        (0, sleep_1.default)(15);
+        return {
+            Sum: results.reduce((acc, r) => acc + r.transformer.Sum, 0),
+        };
+    }),
+});
+exports.child3 = client_1.hatchet.workflow({
+    name: 'child3',
+});
+exports.child3.task({
+    name: 'transformer',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const count = input.N;
+        const promises = Array(count)
+            .fill(null)
+            .map(() => ({ workflow: exports.child2, input }));
+        const results = yield ctx.bulkRunChildren(promises);
+        return {
+            Sum: results.reduce((acc, r) => acc + r.transformer.Sum, 0),
+        };
+    }),
+});
+exports.child4 = client_1.hatchet.workflow({
+    name: 'child4',
+});
+exports.child4.task({
+    name: 'transformer',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const count = input.N;
+        const promises = Array(count)
+            .fill(null)
+            .map(() => ({ workflow: exports.child3, input }));
+        const results = yield ctx.bulkRunChildren(promises);
+        return {
+            Sum: results.reduce((acc, r) => acc + r.transformer.Sum, 0),
+        };
+    }),
+});
+exports.child5 = client_1.hatchet.workflow({
+    name: 'child5',
+});
+exports.child5.task({
+    name: 'transformer',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const count = input.N;
+        const promises = Array(count)
+            .fill(null)
+            .map(() => ({ workflow: exports.child4, input }));
+        const results = yield ctx.bulkRunChildren(promises);
+        return {
+            Sum: results.reduce((acc, r) => acc + r.transformer.Sum, 0),
+        };
+    }),
+});
+exports.parent = client_1.hatchet.workflow({
+    name: 'parent',
+});
+exports.parent.task({
+    name: 'parent',
+    fn: (input, ctx) => __awaiter(void 0, void 0, void 0, function* () {
+        const count = input.N; // Random number between 2-4
+        const promises = Array(count)
+            .fill(null)
+            .map(() => ({ workflow: exports.child5, input }));
+        const results = yield ctx.bulkRunChildren(promises);
+        return {
+            Sum: results.reduce((acc, r) => acc + r.transformer.Sum, 0),
+        };
+    }),
+});

package/v1/examples/legacy/run.d.ts

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

package/v1/examples/legacy/run.js

@@ -0,0 +1,25 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield client_1.hatchet.run(workflow_1.simple, {
+            Message: 'hello',
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.step2);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/legacy/worker.d.ts

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

package/v1/examples/legacy/worker.js

@@ -0,0 +1,24 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('legacy-worker', {
+            workflows: [workflow_1.simple],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/legacy/workflow.d.ts

@@ -0,0 +1,2 @@
+import { Workflow } from '../../../workflow';
+export declare const simple: Workflow;

package/v1/examples/legacy/workflow.js

@@ -0,0 +1,36 @@
+"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 });
+exports.simple = void 0;
+exports.simple = {
+    id: 'legacy-workflow',
+    description: 'test',
+    on: {
+        event: 'user:create',
+    },
+    steps: [
+        {
+            name: 'step1',
+            run: (ctx) => __awaiter(void 0, void 0, void 0, function* () {
+                const input = ctx.workflowInput();
+                return { step1: `original input: ${input.Message}` };
+            }),
+        },
+        {
+            name: 'step2',
+            parents: ['step1'],
+            run: (ctx) => {
+                const step1Output = ctx.stepOutput('step1');
+                return { step2: `step1 output: ${step1Output.step1}` };
+            },
+        },
+    ],
+};

package/v1/examples/on_event/event.d.ts

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

package/v1/examples/on_event/event.js

@@ -0,0 +1,25 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield client_1.hatchet.event.push(workflow_1.SIMPLE_EVENT, {
+            Message: 'hello',
+        });
+        // eslint-disable-next-line no-console
+        console.log(res.eventId);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/on_event/worker.d.ts

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

package/v1/examples/on_event/worker.js

@@ -0,0 +1,24 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const worker = yield client_1.hatchet.worker('on-event-worker', {
+            workflows: [workflow_1.lower, workflow_1.upper],
+        });
+        yield worker.start();
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/on_event/workflow.d.ts

@@ -0,0 +1,17 @@
+export declare const SIMPLE_EVENT = "simple-event:create";
+type Input = {
+    Message: string;
+};
+type LowerOutput = {
+    lower: {
+        TransformedMessage: string;
+    };
+};
+export declare const lower: import("../../workflow").Workflow<Input, LowerOutput>;
+type UpperOutput = {
+    upper: {
+        TransformedMessage: string;
+    };
+};
+export declare const upper: import("../../workflow").Workflow<Input, UpperOutput>;
+export {};

package/v1/examples/on_event/workflow.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upper = exports.lower = exports.SIMPLE_EVENT = void 0;
+const client_1 = require("../client");
+exports.SIMPLE_EVENT = 'simple-event:create';
+exports.lower = client_1.hatchet.workflow({
+    name: 'lower',
+    on: {
+        event: exports.SIMPLE_EVENT,
+    },
+});
+exports.lower.task({
+    name: 'lower',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toLowerCase(),
+        };
+    },
+});
+exports.upper = client_1.hatchet.workflow({
+    name: 'upper',
+    on: {
+        event: exports.SIMPLE_EVENT,
+    },
+});
+exports.upper.task({
+    name: 'upper',
+    fn: (input) => {
+        return {
+            TransformedMessage: input.Message.toUpperCase(),
+        };
+    },
+});

package/v1/examples/simple/cron.d.ts

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

package/v1/examples/simple/cron.js

@@ -0,0 +1,26 @@
+"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 client_1 = require("../client");
+const workflow_1 = require("./workflow");
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const cron = yield workflow_1.simple.cron('simple-daily', '0 0 * * *', {
+            Message: 'hello',
+        });
+        // eslint-disable-next-line no-console
+        console.log(cron.metadata.id);
+        yield client_1.hatchet.cron.delete(cron);
+    });
+}
+if (require.main === module) {
+    main();
+}

package/v1/examples/simple/delay.d.ts

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