@tailor-platform/create-sdk 0.14.3 → 0.15.1

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @tailor-platform/create-sdk
 
+## 0.15.1
+
+## 0.15.0
+
+### Minor Changes
+
+- [#151](https://github.com/tailor-platform/sdk/pull/151) [`b2b26b4`](https://github.com/tailor-platform/sdk/commit/b2b26b4affc4b8b97b193d7421d1a5455f23a331) Thanks [@toiroakr](https://github.com/toiroakr)! - feat!: add workflow test
+
 ## 0.14.3
 
 ## 0.14.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tailor-platform/create-sdk",
-  "version": "0.14.3",
+  "version": "0.15.1",
   "description": "A CLI tool to quickly create a new Tailor Platform SDK project",
   "license": "MIT",
   "type": "module",

package/templates/hello-world/package.json

@@ -12,7 +12,7 @@
   },
   "devDependencies": {
     "@eslint/js": "9.39.1",
-    "@tailor-platform/sdk": "0.14.3",
+    "@tailor-platform/sdk": "0.15.1",
     "@types/node": "22.19.1",
     "eslint": "9.39.1",
     "prettier": "3.7.3",

package/templates/inventory-management/package.json

@@ -18,7 +18,7 @@
   "devDependencies": {
     "@eslint/js": "9.39.1",
     "@tailor-platform/function-types": "0.7.2",
-    "@tailor-platform/sdk": "0.14.3",
+    "@tailor-platform/sdk": "0.15.1",
     "@types/node": "22.19.1",
     "eslint": "9.39.1",
     "prettier": "3.7.3",

package/templates/inventory-management/src/db/order.ts

@@ -9,7 +9,7 @@ export const order = db
       .string({ optional: true })
       .description("Description of the order"),
     orderDate: db.datetime().description("Date of the order"),
-    orderType: db.enum("PURCHASE", "SALES").description("Type of the order"),
+    orderType: db.enum(["PURCHASE", "SALES"]).description("Type of the order"),
     contactId: db
       .uuid()
       .description("Contact associated with the order")

package/templates/inventory-management/src/db/orderItem.ts

@@ -22,7 +22,7 @@ export const orderItem = db
       .description("Unit price of the product")
       .validate(({ value }) => value >= 0),
     totalPrice: db
-      .float({ optional: true, assertNonNull: true })
+      .float({ optional: true })
       .description("Total price of the order item"),
     ...db.fields.timestamps(),
   })

package/templates/inventory-management/src/db/user.ts

@@ -5,7 +5,7 @@ export const user = db
   .type("User", {
     name: db.string().description("Name of the user"),
     email: db.string().unique().description("Email address of the user"),
-    role: db.enum("MANAGER", "STAFF"),
+    role: db.enum(["MANAGER", "STAFF"]),
     ...db.fields.timestamps(),
   })
   .permission(permissionManager)

package/templates/multi-application/apps/user/db/user.ts

@@ -7,7 +7,7 @@ import {
 export const user = db
   .type("User", {
     name: db.string().unique(),
-    role: db.enum("USER", "ADMIN"),
+    role: db.enum(["USER", "ADMIN"]),
     ...db.fields.timestamps(),
   })
   // NOTE: This permits all operations for simplicity.

package/templates/multi-application/package.json

@@ -14,7 +14,7 @@
   },
   "devDependencies": {
     "@eslint/js": "9.39.1",
-    "@tailor-platform/sdk": "0.14.3",
+    "@tailor-platform/sdk": "0.15.1",
     "@types/node": "22.19.1",
     "eslint": "9.39.1",
     "prettier": "3.7.3",

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

@@ -0,0 +1,52 @@
+import { randomUUID } from "node:crypto";
+import { describe, expect, test } from "vitest";
+import { workflowStart } from "@tailor-platform/sdk/cli";
+
+describe.concurrent("workflow", () => {
+  test(
+    "simple-calculation: execute workflow and verify success",
+    { timeout: 120000 },
+    async () => {
+      const { executionId, wait } = await workflowStart({
+        nameOrId: "simple-calculation",
+        machineUser: "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 workflowStart({
+        nameOrId: "user-profile-sync",
+        machineUser: "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/package.json

@@ -21,7 +21,7 @@
   "devDependencies": {
     "@eslint/js": "9.39.1",
     "@tailor-platform/function-types": "0.7.2",
-    "@tailor-platform/sdk": "0.14.3",
+    "@tailor-platform/sdk": "0.15.1",
     "@types/node": "22.19.1",
     "eslint": "9.39.1",
     "graphql-request": "7.3.5",

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

@@ -0,0 +1,37 @@
+import { describe, expect, test, vi } from "vitest";
+import { addNumbers, multiplyNumbers, calculate } from "./simple";
+
+describe("workflow jobs", () => {
+  describe("addNumbers job", () => {
+    test("adds two numbers", () => {
+      const result = addNumbers.body({ a: 2, b: 3 }, { env: {} });
+      expect(result).toBe(5);
+    });
+
+    test("handles negative numbers", () => {
+      const result = addNumbers.body({ a: -5, b: 3 }, { env: {} });
+      expect(result).toBe(-2);
+    });
+  });
+
+  describe("multiplyNumbers job", () => {
+    test("multiplies two numbers", () => {
+      const result = multiplyNumbers.body({ x: 4, y: 5 }, { env: {} });
+      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: {} });
+
+      expect(addNumbers.trigger).toHaveBeenCalledWith({ a: 2, b: 3 });
+      expect(multiplyNumbers.trigger).toHaveBeenCalledWith({ x: 5, y: 2 });
+      expect(result).toBe(10);
+    });
+  });
+});

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

@@ -0,0 +1,29 @@
+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 default createWorkflow({
+  name: "simple-calculation",
+  mainJob: calculate,
+});

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

@@ -0,0 +1,73 @@
+import { describe, expect, test, vi } from "vitest";
+import { type DbOperations, syncUserProfile } from "./wrapTailordb";
+
+describe("syncUserProfile workflow", () => {
+  test("creates new user when not found", async () => {
+    const createdUser = {
+      id: "new-user-id",
+      email: "new@example.com",
+      name: "New User",
+      age: 25,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    const dbOperations = {
+      getUser: vi.fn().mockResolvedValue(undefined),
+      createUser: vi.fn().mockResolvedValue(createdUser),
+      updateUser: vi.fn(),
+    } satisfies DbOperations;
+
+    const result = await syncUserProfile(
+      { name: "New User", email: "new@example.com", age: 25 },
+      dbOperations,
+    );
+
+    expect(result).toEqual({
+      created: true,
+      profile: { name: "New User", email: "new@example.com", age: 25 },
+    });
+    expect(dbOperations.getUser).toHaveBeenCalledExactlyOnceWith(
+      "new@example.com",
+    );
+    expect(dbOperations.createUser).toHaveBeenCalledExactlyOnceWith({
+      name: "New User",
+      email: "new@example.com",
+      age: 25,
+    });
+    expect(dbOperations.updateUser).not.toHaveBeenCalled();
+  });
+
+  test("updates existing user when found", async () => {
+    const existingUser = {
+      id: "existing-user-id",
+      email: "existing@example.com",
+      name: "Old Name",
+      age: 30,
+      createdAt: new Date(),
+      updatedAt: null,
+    };
+    const dbOperations = {
+      getUser: vi.fn().mockResolvedValue(existingUser),
+      createUser: vi.fn(),
+      updateUser: vi.fn(),
+    } satisfies DbOperations;
+
+    const result = await syncUserProfile(
+      { name: "Updated Name", email: "existing@example.com", age: 31 },
+      dbOperations,
+    );
+
+    expect(result).toEqual({
+      created: false,
+      profile: { name: "Updated Name", email: "existing@example.com", age: 31 },
+    });
+    expect(dbOperations.getUser).toHaveBeenCalledExactlyOnceWith(
+      "existing@example.com",
+    );
+    expect(dbOperations.createUser).not.toHaveBeenCalled();
+    expect(dbOperations.updateUser).toHaveBeenCalledExactlyOnceWith(
+      "existing@example.com",
+      { name: "Updated Name", age: 31 },
+    );
+  });
+});

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

@@ -0,0 +1,89 @@
+import { createWorkflowJob, createWorkflow } from "@tailor-platform/sdk";
+import type { Selectable } from "kysely";
+import { getDB, type DB, type Namespace } from "../generated/db";
+
+type User = Selectable<Namespace["main-db"]["User"]>;
+
+export interface UserProfile {
+  name: string;
+  email: string;
+  age: number;
+}
+
+export interface SyncResult {
+  created: boolean;
+  profile: UserProfile;
+}
+
+export interface DbOperations {
+  getUser: (email: string) => Promise<User | undefined>;
+  createUser: (input: UserProfile) => Promise<User>;
+  updateUser: (
+    email: string,
+    input: Omit<UserProfile, "email">,
+  ) => Promise<void>;
+}
+
+function createDbOperations(db: DB<"main-db">): DbOperations {
+  return {
+    getUser: async (email: string) => {
+      return await db
+        .selectFrom("User")
+        .where("email", "=", email)
+        .selectAll()
+        .executeTakeFirst();
+    },
+    createUser: async (input: UserProfile) => {
+      return await db
+        .insertInto("User")
+        .values(input)
+        .returning(["id", "name", "email", "age", "createdAt", "updatedAt"])
+        .executeTakeFirstOrThrow();
+    },
+    updateUser: async (email: string, input: Omit<UserProfile, "email">) => {
+      await db
+        .updateTable("User")
+        .set({ name: input.name, age: input.age })
+        .where("email", "=", email)
+        .execute();
+    },
+  };
+}
+
+export async function syncUserProfile(
+  input: UserProfile,
+  dbOperations: DbOperations,
+): Promise<SyncResult> {
+  const existingUser = await dbOperations.getUser(input.email);
+
+  if (existingUser) {
+    await dbOperations.updateUser(input.email, {
+      name: input.name,
+      age: input.age,
+    });
+    return {
+      created: false,
+      profile: { name: input.name, email: input.email, age: input.age },
+    };
+  }
+
+  const newUser = await dbOperations.createUser(input);
+  return {
+    created: true,
+    profile: { name: newUser.name, email: newUser.email, age: newUser.age },
+  };
+}
+
+export const syncProfile = createWorkflowJob({
+  name: "sync-profile",
+  body: async (input: UserProfile): Promise<SyncResult> => {
+    const db = getDB("main-db");
+    const dbOperations = createDbOperations(db);
+    return await syncUserProfile(input, dbOperations);
+  },
+});
+
+export default createWorkflow({
+  name: "user-profile-sync",
+  mainJob: syncProfile,
+});

package/templates/testing/tailor.config.ts

@@ -15,6 +15,7 @@ export default defineConfig({
   }),
   db: { "main-db": { files: ["./src/db/*.ts"] } },
   resolver: { "main-resolver": { files: ["./src/resolver/*.ts"] } },
+  workflow: { files: ["./src/workflow/*.ts"] },
 });
 
 export const generators = defineGenerators([