@tailor-platform/create-sdk 1.20.0 → 1.22.0

package/templates/workflow/src/workflow/order-fulfillment.test.ts

@@ -0,0 +1,133 @@
+import { WORKFLOW_TEST_ENV_KEY } from "@tailor-platform/sdk/test";
+import { afterEach, describe, expect, test, vi } from "vitest";
+import workflow, {
+  fulfillOrder,
+  processPayment,
+  sendConfirmation,
+  validateOrder,
+} from "./order-fulfillment";
+
+describe("order fulfillment workflow", () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+    vi.restoreAllMocks();
+  });
+
+  describe("individual job tests with .body()", () => {
+    test("validateOrder accepts valid order", () => {
+      const result = validateOrder.body({ orderId: "order-1", amount: 100 }, { env: {} });
+      expect(result).toEqual({ valid: true, orderId: "order-1" });
+    });
+
+    test("validateOrder rejects zero amount", () => {
+      expect(() => validateOrder.body({ orderId: "order-1", amount: 0 }, { env: {} })).toThrow(
+        "Order amount must be positive",
+      );
+    });
+
+    test("processPayment returns transaction", () => {
+      const result = processPayment.body({ orderId: "order-1", amount: 100 }, { env: {} });
+      expect(result).toEqual({
+        transactionId: "txn-order-1",
+        amount: 100,
+        status: "completed",
+      });
+    });
+
+    test("sendConfirmation returns confirmation", () => {
+      const result = sendConfirmation.body(
+        { orderId: "order-1", transactionId: "txn-1" },
+        { env: {} },
+      );
+      expect(result).toEqual({
+        orderId: "order-1",
+        transactionId: "txn-1",
+        confirmed: true,
+      });
+    });
+  });
+
+  describe("orchestration tests with mocked triggers", () => {
+    test("fulfillOrder chains all jobs", async () => {
+      vi.spyOn(validateOrder, "trigger").mockResolvedValue({
+        valid: true,
+        orderId: "order-1",
+      });
+      vi.spyOn(processPayment, "trigger").mockResolvedValue({
+        transactionId: "txn-order-1",
+        amount: 100,
+        status: "completed" as const,
+      });
+      vi.spyOn(sendConfirmation, "trigger").mockResolvedValue({
+        orderId: "order-1",
+        transactionId: "txn-order-1",
+        confirmed: true,
+      });
+
+      const result = await fulfillOrder.body({ orderId: "order-1", amount: 100 }, { env: {} });
+
+      expect(validateOrder.trigger).toHaveBeenCalledWith({
+        orderId: "order-1",
+        amount: 100,
+      });
+      expect(processPayment.trigger).toHaveBeenCalledWith({
+        orderId: "order-1",
+        amount: 100,
+      });
+      expect(sendConfirmation.trigger).toHaveBeenCalledWith({
+        orderId: "order-1",
+        transactionId: "txn-order-1",
+      });
+      expect(result).toEqual({
+        orderId: "order-1",
+        transactionId: "txn-order-1",
+        confirmed: true,
+        paymentStatus: "completed",
+      });
+    });
+
+    test("workflow.mainJob.body() chains all jobs", async () => {
+      vi.spyOn(validateOrder, "trigger").mockResolvedValue({
+        valid: true,
+        orderId: "order-2",
+      });
+      vi.spyOn(processPayment, "trigger").mockResolvedValue({
+        transactionId: "txn-order-2",
+        amount: 200,
+        status: "completed" as const,
+      });
+      vi.spyOn(sendConfirmation, "trigger").mockResolvedValue({
+        orderId: "order-2",
+        transactionId: "txn-order-2",
+        confirmed: true,
+      });
+
+      const result = await workflow.mainJob.body({ orderId: "order-2", amount: 200 }, { env: {} });
+
+      expect(result).toEqual({
+        orderId: "order-2",
+        transactionId: "txn-order-2",
+        confirmed: true,
+        paymentStatus: "completed",
+      });
+    });
+  });
+
+  describe("integration tests with .trigger()", () => {
+    test("workflow.mainJob.trigger() executes all jobs", async () => {
+      vi.stubEnv(WORKFLOW_TEST_ENV_KEY, JSON.stringify({}));
+
+      const result = await workflow.mainJob.trigger({
+        orderId: "order-3",
+        amount: 300,
+      });
+
+      expect(result).toEqual({
+        orderId: "order-3",
+        transactionId: "txn-order-3",
+        confirmed: true,
+        paymentStatus: "completed",
+      });
+    });
+  });
+});

package/templates/workflow/src/workflow/order-fulfillment.ts

@@ -0,0 +1,69 @@
+import { createWorkflow, createWorkflowJob } from "@tailor-platform/sdk";
+
+export const validateOrder = createWorkflowJob({
+  name: "validate-order",
+  body: (input: { orderId: string; amount: number }) => {
+    if (input.amount <= 0) {
+      throw new Error("Order amount must be positive");
+    }
+    return { valid: true, orderId: input.orderId };
+  },
+});
+
+export const processPayment = createWorkflowJob({
+  name: "process-payment",
+  body: (input: { orderId: string; amount: number }) => {
+    return {
+      transactionId: `txn-${input.orderId}`,
+      amount: input.amount,
+      status: "completed" as const,
+    };
+  },
+});
+
+export const sendConfirmation = createWorkflowJob({
+  name: "send-confirmation",
+  body: (input: { orderId: string; transactionId: string }) => {
+    return {
+      orderId: input.orderId,
+      transactionId: input.transactionId,
+      confirmed: true,
+    };
+  },
+});
+
+export const fulfillOrder = createWorkflowJob({
+  name: "fulfill-order",
+  body: async (input: { orderId: string; amount: number }) => {
+    const validation = await validateOrder.trigger({
+      orderId: input.orderId,
+      amount: input.amount,
+    });
+
+    if (!validation.valid) {
+      throw new Error("Order validation failed");
+    }
+
+    const payment = await processPayment.trigger({
+      orderId: input.orderId,
+      amount: input.amount,
+    });
+
+    const confirmation = await sendConfirmation.trigger({
+      orderId: input.orderId,
+      transactionId: payment.transactionId,
+    });
+
+    return {
+      orderId: confirmation.orderId,
+      transactionId: confirmation.transactionId,
+      confirmed: confirmation.confirmed,
+      paymentStatus: payment.status,
+    };
+  },
+});
+
+export default createWorkflow({
+  name: "order-fulfillment",
+  mainJob: fulfillOrder,
+});

package/templates/{testing/src/workflow/wrapTailordb.test.ts → workflow/src/workflow/sync-profile.test.ts}

@@ -1,5 +1,5 @@
 import { describe, expect, test, vi } from "vitest";
-import { type DbOperations, syncUserProfile } from "./wrapTailordb";
+import { type DbOperations, syncUserProfile } from "./sync-profile";
 
 describe("syncUserProfile workflow", () => {
   test("creates new user when not found", async () => {

package/templates/{testing → workflow}/tailor.config.ts

@@ -2,7 +2,7 @@ import { defineAuth, defineConfig, definePlugins, t } from "@tailor-platform/sdk
 import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";
 
 export default defineConfig({
-  name: "testing",
+  name: "workflow",
   auth: defineAuth("main-auth", {
     machineUserAttributes: {
       role: t.string(),

package/templates/workflow/tests/bundled.test.ts

@@ -0,0 +1,145 @@
+import path from "node:path";
+import { createImportMain, setupTailordbMock, setupWorkflowMock } from "@tailor-platform/sdk/test";
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
+
+const outputDir = path.join(__dirname, "../.tailor-sdk");
+
+describe("bundled workflow execution", () => {
+  let executedQueries: { query: string; params: unknown[] }[];
+
+  const importMain = createImportMain(outputDir);
+
+  beforeAll(() => {
+    ({ executedQueries } = setupTailordbMock());
+  });
+
+  beforeEach(() => {
+    executedQueries.length = 0;
+  });
+
+  describe("sync-profile job", () => {
+    test("creates new user when not found", async () => {
+      let selectCalled = false;
+      setupTailordbMock((query) => {
+        if (query.includes("SELECT") || query.includes("select")) {
+          if (!selectCalled) {
+            selectCalled = true;
+            return [];
+          }
+        }
+        if (query.includes("INSERT") || query.includes("insert")) {
+          return [
+            {
+              id: "new-id",
+              name: "Alice",
+              email: "alice@example.com",
+              age: 25,
+              createdAt: "2024-01-01",
+              updatedAt: null,
+            },
+          ];
+        }
+        return [];
+      });
+
+      const main = await importMain("workflow-jobs/sync-profile.js");
+      const result = await main({ name: "Alice", email: "alice@example.com", age: 25 });
+      expect(result).toEqual({
+        created: true,
+        profile: { name: "Alice", email: "alice@example.com", age: 25 },
+      });
+    });
+
+    test("updates existing user when found", async () => {
+      setupTailordbMock((query) => {
+        if (query.includes("SELECT") || query.includes("select")) {
+          return [
+            {
+              id: "existing-id",
+              name: "Old Name",
+              email: "alice@example.com",
+              age: 20,
+              createdAt: "2024-01-01",
+              updatedAt: null,
+            },
+          ];
+        }
+        return [];
+      });
+
+      const main = await importMain("workflow-jobs/sync-profile.js");
+      const result = await main({ name: "Alice Updated", email: "alice@example.com", age: 26 });
+      expect(result).toEqual({
+        created: false,
+        profile: { name: "Alice Updated", email: "alice@example.com", age: 26 },
+      });
+    });
+  });
+
+  describe("order-fulfillment jobs", () => {
+    test("validate-order validates positive amount", async () => {
+      const main = await importMain("workflow-jobs/validate-order.js");
+      const result = await main({ orderId: "order-1", amount: 100 });
+      expect(result).toEqual({ valid: true, orderId: "order-1" });
+    });
+
+    test("validate-order throws for non-positive amount", async () => {
+      const main = await importMain("workflow-jobs/validate-order.js");
+      await expect(main({ orderId: "order-1", amount: 0 })).rejects.toThrow(
+        "Order amount must be positive",
+      );
+    });
+
+    test("process-payment returns transaction", async () => {
+      const main = await importMain("workflow-jobs/process-payment.js");
+      const result = await main({ orderId: "order-1", amount: 100 });
+      expect(result).toEqual({
+        transactionId: "txn-order-1",
+        amount: 100,
+        status: "completed",
+      });
+    });
+
+    test("send-confirmation returns confirmation", async () => {
+      const main = await importMain("workflow-jobs/send-confirmation.js");
+      const result = await main({ orderId: "order-1", transactionId: "txn-order-1" });
+      expect(result).toEqual({
+        orderId: "order-1",
+        transactionId: "txn-order-1",
+        confirmed: true,
+      });
+    });
+
+    test("fulfill-order orchestrates all jobs", async () => {
+      setupWorkflowMock((jobName, args) => {
+        switch (jobName) {
+          case "validate-order":
+            return { valid: true, orderId: (args as { orderId: string }).orderId };
+          case "process-payment":
+            return {
+              transactionId: `txn-${(args as { orderId: string }).orderId}`,
+              amount: (args as { amount: number }).amount,
+              status: "completed",
+            };
+          case "send-confirmation":
+            return {
+              orderId: (args as { orderId: string }).orderId,
+              transactionId: (args as { transactionId: string }).transactionId,
+              confirmed: true,
+            };
+          default:
+            throw new Error(`Unknown job: ${jobName}`);
+        }
+      });
+
+      const main = await importMain("workflow-jobs/fulfill-order.js");
+      const result = await main({ orderId: "order-1", amount: 100 });
+      expect(result).toEqual({
+        orderId: "order-1",
+        transactionId: "txn-order-1",
+        confirmed: true,
+        paymentStatus: "completed",
+      });
+    });
+  });
+});

package/templates/workflow/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true,
+    "esModuleInterop": true,
+    "allowJs": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "types": ["node", "@tailor-platform/function-types"]
+  },
+  "include": ["**/*.ts"]
+}

package/templates/workflow/user-defined.d.ts

@@ -0,0 +1,15 @@
+// This file is auto-generated by @tailor-platform/sdk
+// Do not edit this file manually
+// Regenerated automatically when running 'tailor-sdk apply' or 'tailor-sdk generate'
+
+declare module "@tailor-platform/sdk" {
+  interface AttributeMap {
+    role: string;
+  }
+  interface AttributeList {
+    __tuple?: [];
+  }
+  interface Env {}
+}
+
+export {};

package/templates/{testing → workflow}/vitest.config.ts

@@ -10,6 +10,12 @@ export default defineConfig({
           include: ["src/**/*.test.ts"],
         },
       },
+      {
+        test: {
+          name: { label: "bundled", color: "yellow" },
+          include: ["tests/**/*.test.ts"],
+        },
+      },
       {
         test: {
           name: { label: "e2e", color: "green" },

package/templates/testing/README.md

@@ -1,130 +0,0 @@
-# Testing Guide
-
-This guide covers testing patterns for Tailor Platform SDK applications using [Vitest](https://vitest.dev/).
-
-This project was bootstrapped with [Create Tailor Platform SDK](https://www.npmjs.com/package/@tailor-platform/create-sdk).
-
-## Quick Start
-
-### Unit Tests
-
-Run unit tests locally without deployment:
-
-```bash
-npm run test:unit
-```
-
-### End-to-End (E2E) Tests
-
-E2E tests require a deployed application.
-
-#### Local Development
-
-```bash
-# 1. Login
-npx tailor-sdk login
-
-# 2. Create workspace
-npx tailor-sdk workspace create --name <workspace-name> --region <workspace-region>
-
-# 3. Deploy application
-export TAILOR_PLATFORM_WORKSPACE_ID=<your-workspace-id>
-npm run deploy
-
-# 4. Run E2E tests
-npm run test:e2e
-```
-
-#### CI/CD (Automated Workspace Lifecycle)
-
-```bash
-npx tailor-sdk login
-export CI=true
-export TAILOR_PLATFORM_WORKSPACE_NAME=<workspace-name>
-export TAILOR_PLATFORM_WORKSPACE_REGION=<workspace-region>
-npm run test:e2e  # Automatically creates, deploys, tests, and deletes workspace
-```
-
-## Testing Patterns
-
-### Unit Tests
-
-Unit tests verify resolver logic without requiring deployment.
-
-#### Simple Resolver Testing
-
-**Example:** [src/resolver/simple.test.ts](src/resolver/simple.test.ts)
-
-Test resolvers by directly calling `resolver.body()` with mock inputs.
-
-**Key points:**
-
-- Use `unauthenticatedTailorUser` for testing logic that doesn't depend on user context
-- **Best for:** Calculations, data transformations without database dependencies
-
-#### Mock TailorDB Client
-
-**Example:** [src/resolver/mockTailordb.test.ts](src/resolver/mockTailordb.test.ts)
-
-Mock the global `tailordb.Client` using `vi.stubGlobal()` to simulate database operations and control responses for each query.
-
-**Key points:**
-
-- Control exact database responses (query results, errors)
-- Verify database interaction flow (transactions, queries)
-- Test transaction rollback scenarios
-- **Best for:** Business logic with simple database operations
-
-#### Dependency Injection Pattern
-
-**Example:** [src/resolver/wrapTailordb.test.ts](src/resolver/wrapTailordb.test.ts)
-
-Extract database operations into a `DbOperations` interface, allowing business logic to be tested independently from Kysely implementation.
-
-**Key points:**
-
-- Test business logic independently from Kysely implementation details
-- Mock high-level operations instead of low-level SQL queries
-- **Best for:** Complex business logic with multiple database operations
-
-### End-to-End (E2E) Tests
-
-E2E tests verify your application works correctly when deployed to Tailor Platform. They test the full stack including GraphQL API, database operations, and authentication.
-
-**Examples:** [e2e/resolver.test.ts](e2e/resolver.test.ts), [e2e/globalSetup.ts](e2e/globalSetup.ts)
-
-#### How It Works
-
-**1. Global Setup** ([e2e/globalSetup.ts](e2e/globalSetup.ts))
-
-Before running tests, `globalSetup` retrieves deployment information:
-
-- Application URL via `show()`
-- Machine user access token via `machineUserToken()`
-- Provides credentials to tests via `inject("url")` and `inject("token")`
-
-**2. Test Files** ([e2e/resolver.test.ts](e2e/resolver.test.ts))
-
-Tests create a GraphQL client using injected credentials and send real queries/mutations to the deployed application.
-
-**Key points:**
-
-- Tests run against actual deployed application
-- `inject("url")` and `inject("token")` provide deployment credentials automatically
-- Machine user authentication enables API access without manual token management
-- Verify database persistence and API contracts
-- **Best for:** Integration testing, end-to-end API validation
-
-## Available Scripts
-
-| Script         | Description                                  |
-| -------------- | -------------------------------------------- |
-| `generate`     | Generate TypeScript types from configuration |
-| `deploy`       | Deploy application to Tailor Platform        |
-| `test:unit`    | Run unit tests locally                       |
-| `test:e2e`     | Run E2E tests against deployed application   |
-| `format`       | Format code with Prettier                    |
-| `format:check` | Check code formatting                        |
-| `lint`         | Lint code with ESLint                        |
-| `lint:fix`     | Fix linting issues automatically             |
-| `typecheck`    | Run TypeScript type checking                 |

package/templates/testing/e2e/resolver.test.ts

@@ -1,57 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { gql, GraphQLClient } from "graphql-request";
-import { describe, expect, inject, test } from "vitest";
-
-function createGraphQLClient() {
-  const endpoint = new URL("/query", inject("url")).href;
-  return new GraphQLClient(endpoint, {
-    headers: {
-      Authorization: `Bearer ${inject("token")}`,
-    },
-    // Prevent throwing errors on GraphQL errors.
-    errorPolicy: "all",
-  });
-}
-
-describe("resolver", () => {
-  const graphQLClient = createGraphQLClient();
-
-  describe("incrementUserAge", () => {
-    const uuid = randomUUID();
-
-    test("prepare data", async () => {
-      const query = gql`
-        mutation {
-          createUser(input: {
-            name: "alice"
-            email: "alice-${uuid}@example.com"
-            age: 30
-          }) {
-            id
-          }
-        }
-      `;
-      const result = await graphQLClient.rawRequest(query);
-      expect(result.errors).toBeUndefined();
-    });
-
-    test("basic functionality", async () => {
-      const query = gql`
-        mutation {
-          incrementUserAge(email: "alice-${uuid}@example.com") {
-            oldAge
-            newAge
-          }
-        }
-      `;
-      const result = await graphQLClient.rawRequest(query);
-      expect(result.errors).toBeUndefined();
-      expect(result.data).toEqual({
-        incrementUserAge: {
-          oldAge: 30,
-          newAge: 31,
-        },
-      });
-    });
-  });
-});

package/templates/testing/e2e/workflow.test.ts

@@ -1,47 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { describe, expect, test } from "vitest";
-import { startWorkflow } from "@tailor-platform/sdk/cli";
-import config from "../tailor.config";
-import simpleCalculationWorkflow from "../src/workflow/simple";
-import userProfileSyncWorkflow from "../src/workflow/wrapTailordb";
-
-describe.concurrent("workflow", () => {
-  test("simple-calculation: execute workflow and verify success", { timeout: 120000 }, async () => {
-    const { executionId, wait } = await startWorkflow({
-      workflow: simpleCalculationWorkflow,
-      authInvoker: config.auth.invoker("admin"),
-      arg: { a: 2, b: 3 },
-    });
-
-    console.log(`[simple-calculation] Execution ID: ${executionId}`);
-
-    const result = await wait();
-    expect(result).toMatchObject({
-      workflowName: "simple-calculation",
-      status: "SUCCESS",
-    });
-  });
-
-  test("user-profile-sync: execute workflow and verify success", { timeout: 120000 }, async () => {
-    const uuid = randomUUID();
-    const testEmail = `workflow-test-${uuid}@example.com`;
-
-    const { executionId, wait } = await startWorkflow({
-      workflow: userProfileSyncWorkflow,
-      authInvoker: config.auth.invoker("admin"),
-      arg: {
-        name: "workflow-test-user",
-        email: testEmail,
-        age: 25,
-      },
-    });
-
-    console.log(`[user-profile-sync] Execution ID: ${executionId}`);
-
-    const result = await wait();
-    expect(result).toMatchObject({
-      workflowName: "user-profile-sync",
-      status: "SUCCESS",
-    });
-  });
-});

package/templates/testing/src/resolver/simple.test.ts

@@ -1,14 +0,0 @@
-import { unauthenticatedTailorUser } from "@tailor-platform/sdk";
-import { describe, expect, test } from "vitest";
-import resolver from "./simple";
-
-describe("add resolver", () => {
-  test("basic functionality", async () => {
-    const result = await resolver.body({
-      input: { left: 1, right: 2 },
-      user: unauthenticatedTailorUser,
-      env: {},
-    });
-    expect(result).toBe(3);
-  });
-});