@tailor-platform/create-sdk 1.19.0 → 1.21.0

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

@@ -0,0 +1,148 @@
+import { WORKFLOW_TEST_ENV_KEY, unauthenticatedTailorUser } 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: {}, user: unauthenticatedTailorUser },
+      );
+      expect(result).toEqual({ valid: true, orderId: "order-1" });
+    });
+
+    test("validateOrder rejects zero amount", () => {
+      expect(() =>
+        validateOrder.body(
+          { orderId: "order-1", amount: 0 },
+          { env: {}, user: unauthenticatedTailorUser },
+        ),
+      ).toThrow("Order amount must be positive");
+    });
+
+    test("processPayment returns transaction", () => {
+      const result = processPayment.body(
+        { orderId: "order-1", amount: 100 },
+        { env: {}, user: unauthenticatedTailorUser },
+      );
+      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: {}, user: unauthenticatedTailorUser },
+      );
+      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: {}, user: unauthenticatedTailorUser },
+      );
+
+      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: {}, user: unauthenticatedTailorUser },
+      );
+
+      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/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/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);
-  });
-});

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

@@ -1,88 +0,0 @@
-import { unauthenticatedTailorUser } from "@tailor-platform/sdk/test";
-import { describe, expect, test, vi } from "vitest";
-import { addNumbers, multiplyNumbers, calculate, getUserInfo } from "./simple";
-
-describe("workflow jobs", () => {
-  describe("addNumbers job", () => {
-    test("adds two numbers", () => {
-      const result = addNumbers.body(
-        { a: 2, b: 3 },
-        {
-          env: {},
-          user: unauthenticatedTailorUser,
-        },
-      );
-      expect(result).toBe(5);
-    });
-
-    test("handles negative numbers", () => {
-      const result = addNumbers.body(
-        { a: -5, b: 3 },
-        {
-          env: {},
-          user: unauthenticatedTailorUser,
-        },
-      );
-      expect(result).toBe(-2);
-    });
-  });
-
-  describe("multiplyNumbers job", () => {
-    test("multiplies two numbers", () => {
-      const result = multiplyNumbers.body(
-        { x: 4, y: 5 },
-        {
-          env: {},
-          user: unauthenticatedTailorUser,
-        },
-      );
-      expect(result).toBe(20);
-    });
-  });
-
-  describe("calculate job", () => {
-    test("calculates (a + b) * a", async () => {
-      // Mock the trigger methods for dependent jobs
-      vi.spyOn(addNumbers, "trigger").mockResolvedValue(5); // 2 + 3 = 5
-      vi.spyOn(multiplyNumbers, "trigger").mockResolvedValue(10); // 5 * 2 = 10
-
-      const result = await calculate.body(
-        { a: 2, b: 3 },
-        {
-          env: {},
-          user: unauthenticatedTailorUser,
-        },
-      );
-
-      expect(addNumbers.trigger).toHaveBeenCalledWith({ a: 2, b: 3 });
-      expect(multiplyNumbers.trigger).toHaveBeenCalledWith({ x: 5, y: 2 });
-      expect(result).toBe(10);
-    });
-  });
-
-  describe("getUserInfo job", () => {
-    test("returns user info from context", () => {
-      const result = getUserInfo.body(undefined, {
-        env: {},
-        user: unauthenticatedTailorUser,
-      });
-      expect(result).toEqual({
-        userId: unauthenticatedTailorUser.id,
-        workspaceId: unauthenticatedTailorUser.workspaceId,
-      });
-    });
-
-    test("returns custom user info", () => {
-      const customUser = {
-        ...unauthenticatedTailorUser,
-        id: "user-123",
-        workspaceId: "ws-456",
-      };
-      const result = getUserInfo.body(undefined, {
-        env: {},
-        user: customUser,
-      });
-      expect(result).toEqual({ userId: "user-123", workspaceId: "ws-456" });
-    });
-  });
-});

package/templates/testing/src/workflow/simple.ts

@@ -1,36 +0,0 @@
-import { createWorkflowJob, createWorkflow } from "@tailor-platform/sdk";
-
-export const addNumbers = createWorkflowJob({
-  name: "add-numbers",
-  body: (input: { a: number; b: number }) => {
-    return input.a + input.b;
-  },
-});
-
-export const multiplyNumbers = createWorkflowJob({
-  name: "multiply-numbers",
-  body: (input: { x: number; y: number }) => {
-    return input.x * input.y;
-  },
-});
-
-export const calculate = createWorkflowJob({
-  name: "calculate",
-  body: async (input: { a: number; b: number }) => {
-    const sum = await addNumbers.trigger({ a: input.a, b: input.b });
-    const product = await multiplyNumbers.trigger({ x: sum, y: input.a });
-    return product;
-  },
-});
-
-export const getUserInfo = createWorkflowJob({
-  name: "get-user-info",
-  body: (_input: undefined, { user }) => {
-    return { userId: user.id, workspaceId: user.workspaceId };
-  },
-});
-
-export default createWorkflow({
-  name: "simple-calculation",
-  mainJob: calculate,
-});