@tailor-platform/create-sdk 2.0.0-next.1 → 2.0.0-next.10

package/templates/workflow/package.json

@@ -1,10 +1,11 @@
 {
   "name": "workflow",
+  "version": "0.0.0",
   "private": true,
   "type": "module",
   "scripts": {
-    "generate": "tailor-sdk generate",
-    "deploy": "tailor-sdk deploy",
+    "generate": "tailor generate",
+    "deploy": "tailor deploy",
     "test": "vitest --project unit",
     "test:unit": "vitest --project unit",
     "test:e2e": "vitest --project e2e",
@@ -15,14 +16,15 @@
     "typecheck": "tsc --noEmit"
   },
   "devDependencies": {
-    "@tailor-platform/sdk": "2.0.0-next.1",
-    "@types/node": "24.13.2",
-    "graphql": "16.14.2",
+    "@tailor-platform/eslint-plugin-sdk": "0.2.0-next.0",
+    "@tailor-platform/sdk": "2.0.0-next.10",
+    "@types/node": "24.13.3",
+    "graphql": "17.0.2",
     "graphql-request": "7.4.0",
-    "oxfmt": "0.54.0",
-    "oxlint": "1.69.0",
-    "oxlint-tsgolint": "0.23.0",
-    "typescript": "5.9.3",
-    "vitest": "4.1.8"
+    "oxfmt": "0.59.0",
+    "oxlint": "1.74.0",
+    "oxlint-tsgolint": "0.25.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.10"
   }
 }

package/templates/workflow/src/db/order.ts

@@ -1,7 +1,7 @@
 import { db } from "@tailor-platform/sdk";
 
 export const order = db
-  .type("Order", {
+  .table("Order", {
     customerName: db.string(),
     amount: db.int(),
     status: db.enum(["PENDING", "PROCESSING", "COMPLETED", "FAILED"]),

package/templates/workflow/src/db/user.ts

@@ -1,7 +1,7 @@
 import { db } from "@tailor-platform/sdk";
 
 export const user = db
-  .type("User", {
+  .table("User", {
     name: db.string(),
     email: db.string().unique(),
     age: db.int(),

package/templates/workflow/src/generated/db.ts

@@ -19,7 +19,7 @@ export interface Namespace {
       amount: number;
       status: "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED";
       createdAt: Generated<Timestamp>;
-      updatedAt: Timestamp | null;
+      updatedAt: Generated<Timestamp>;
     }
 
     User: {
@@ -28,7 +28,7 @@ export interface Namespace {
       email: string;
       age: number;
       createdAt: Generated<Timestamp>;
-      updatedAt: Timestamp | null;
+      updatedAt: Generated<Timestamp>;
     }
   }
 }

package/templates/workflow/src/resolver/resolveApproval.test.ts

@@ -1,42 +1,47 @@
 import { describe, expect, test } from "vitest";
 import { mockWorkflow } from "@tailor-platform/sdk/vitest";
-import { unauthenticatedTailorUser } from "@tailor-platform/sdk/test";
+import { approval } from "../workflow/approval";
 import resolver from "./resolveApproval";
 
 describe("resolveApproval resolver", () => {
   test("resolves approval with approved=true", async () => {
     using wf = mockWorkflow();
-    wf.setResolveHandler((_executionId, _key, callback) => {
-      const callbackResult = callback({
-        message: "Please approve order order-1",
-        orderId: "order-1",
-      });
-      expect(callbackResult).toEqual({ approved: true });
+    const approvalMock = wf.waitPoint(approval);
+    const payload = {
+      message: "Please approve order order-1",
+      orderId: "order-1",
+    };
+    approvalMock.resolve.mockImplementation(async (_executionId, callback) => {
+      expect(await callback(payload)).toEqual({ approved: true });
     });
 
     const result = await resolver.body({
       input: { executionId: "exec-1", approved: true },
-      user: unauthenticatedTailorUser,
+      caller: null,
+      invoker: null,
       env: {},
     });
 
     expect(result).toEqual({ resolved: true });
-    expect(wf.resolveCalls).toEqual([{ executionId: "exec-1", key: "approval" }]);
+    expect(approvalMock.resolve).toHaveBeenCalledWith("exec-1", expect.any(Function));
   });
 
   test("resolves approval with approved=false", async () => {
     using wf = mockWorkflow();
-    wf.setResolveHandler((_executionId, _key, callback) => {
-      const callbackResult = callback({ message: "Please approve", orderId: "order-2" });
-      expect(callbackResult).toEqual({ approved: false });
+    const approvalMock = wf.waitPoint(approval);
+    const payload = { message: "Please approve", orderId: "order-2" };
+    approvalMock.resolve.mockImplementation(async (_executionId, callback) => {
+      expect(await callback(payload)).toEqual({ approved: false });
     });
 
     const result = await resolver.body({
       input: { executionId: "exec-2", approved: false },
-      user: unauthenticatedTailorUser,
+      caller: null,
+      invoker: null,
       env: {},
     });
 
     expect(result).toEqual({ resolved: true });
+    expect(approvalMock.resolve).toHaveBeenCalledWith("exec-2", expect.any(Function));
   });
 });

package/templates/workflow/src/workflow/approval.test.ts

@@ -1,28 +1,33 @@
 import { describe, expect, test } from "vitest";
 import { mockWorkflow } from "@tailor-platform/sdk/vitest";
-import workflow, { processWithApproval } from "./approval";
+import workflow, { approval, processWithApproval } from "./approval";
 
 describe("approval workflow", () => {
   test("approved flow returns approved status", async () => {
     using wf = mockWorkflow();
-    wf.setWaitHandler((_key, _payload) => ({ approved: true }));
+    const approvalMock = wf.waitPoint(approval);
+    approvalMock.wait.mockResolvedValue({ approved: true });
 
-    const result = await processWithApproval.body({ orderId: "order-1" }, { env: {} });
+    const result = await processWithApproval.body(
+      { orderId: "order-1" },
+      { env: {}, invoker: null },
+    );
 
     expect(result).toEqual({ orderId: "order-1", status: "approved" });
-    expect(wf.waitCalls).toEqual([
-      {
-        key: "approval",
-        payload: { message: "Please approve order order-1", orderId: "order-1" },
-      },
-    ]);
+    expect(approvalMock.wait).toHaveBeenCalledWith({
+      message: "Please approve order order-1",
+      orderId: "order-1",
+    });
   });
 
   test("rejected flow returns rejected status", async () => {
     using wf = mockWorkflow();
-    wf.setWaitHandler({ approved: false });
+    wf.waitPoint(approval).wait.mockResolvedValue({ approved: false });
 
-    const result = await processWithApproval.body({ orderId: "order-2" }, { env: {} });
+    const result = await processWithApproval.body(
+      { orderId: "order-2" },
+      { env: {}, invoker: null },
+    );
 
     expect(result).toEqual({ orderId: "order-2", status: "rejected" });
   });

package/templates/workflow/src/workflow/approval.ts

@@ -1,6 +1,6 @@
-import { createWorkflow, createWorkflowJob, defineWaitPoints } from "@tailor-platform/sdk";
+import { createWaitPoints, createWorkflow, createWorkflowJob } from "@tailor-platform/sdk";
 
-export const { approval } = defineWaitPoints((define) => ({
+export const { approval } = createWaitPoints((define) => ({
   /** Approval for order processing */
   approval: define<{ message: string; orderId: string }, { approved: boolean }>(),
 }));

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

@@ -10,18 +10,24 @@ import workflow, {
 describe("order fulfillment workflow", () => {
   describe("individual job tests with .body()", () => {
     test("validateOrder accepts valid order", () => {
-      const result = validateOrder.body({ orderId: "order-1", amount: 100 }, { env: {} });
+      const result = validateOrder.body(
+        { orderId: "order-1", amount: 100 },
+        { env: {}, invoker: null },
+      );
       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",
-      );
+      expect(() =>
+        validateOrder.body({ orderId: "order-1", amount: 0 }, { env: {}, invoker: null }),
+      ).toThrow("Order amount must be positive");
     });
 
     test("processPayment returns transaction", () => {
-      const result = processPayment.body({ orderId: "order-1", amount: 100 }, { env: {} });
+      const result = processPayment.body(
+        { orderId: "order-1", amount: 100 },
+        { env: {}, invoker: null },
+      );
       expect(result).toEqual({
         transactionId: "txn-order-1",
         amount: 100,
@@ -32,7 +38,7 @@ describe("order fulfillment workflow", () => {
     test("sendConfirmation returns confirmation", () => {
       const result = sendConfirmation.body(
         { orderId: "order-1", transactionId: "txn-1" },
-        { env: {} },
+        { env: {}, invoker: null },
       );
       expect(result).toEqual({
         orderId: "order-1",
@@ -42,34 +48,37 @@ describe("order fulfillment workflow", () => {
     });
   });
 
-  describe("orchestration tests with mocked triggers", () => {
+  describe("orchestration tests with mocked starts", () => {
     test("fulfillOrder chains all jobs", async () => {
-      using _validateSpy = vi.spyOn(validateOrder, "trigger").mockReturnValue({
+      using _validateSpy = vi.spyOn(validateOrder, "start").mockReturnValue({
         valid: true,
         orderId: "order-1",
       });
-      using _paymentSpy = vi.spyOn(processPayment, "trigger").mockReturnValue({
+      using _paymentSpy = vi.spyOn(processPayment, "start").mockReturnValue({
         transactionId: "txn-order-1",
         amount: 100,
         status: "completed" as const,
       });
-      using _confirmSpy = vi.spyOn(sendConfirmation, "trigger").mockReturnValue({
+      using _confirmSpy = vi.spyOn(sendConfirmation, "start").mockReturnValue({
         orderId: "order-1",
         transactionId: "txn-order-1",
         confirmed: true,
       });
 
-      const result = await fulfillOrder.body({ orderId: "order-1", amount: 100 }, { env: {} });
+      const result = await fulfillOrder.body(
+        { orderId: "order-1", amount: 100 },
+        { env: {}, invoker: null },
+      );
 
-      expect(validateOrder.trigger).toHaveBeenCalledWith({
+      expect(validateOrder.start).toHaveBeenCalledWith({
         orderId: "order-1",
         amount: 100,
       });
-      expect(processPayment.trigger).toHaveBeenCalledWith({
+      expect(processPayment.start).toHaveBeenCalledWith({
         orderId: "order-1",
         amount: 100,
       });
-      expect(sendConfirmation.trigger).toHaveBeenCalledWith({
+      expect(sendConfirmation.start).toHaveBeenCalledWith({
         orderId: "order-1",
         transactionId: "txn-order-1",
       });
@@ -82,22 +91,25 @@ describe("order fulfillment workflow", () => {
     });
 
     test("workflow.mainJob.body() chains all jobs", async () => {
-      using _validateSpy = vi.spyOn(validateOrder, "trigger").mockReturnValue({
+      using _validateSpy = vi.spyOn(validateOrder, "start").mockReturnValue({
         valid: true,
         orderId: "order-2",
       });
-      using _paymentSpy = vi.spyOn(processPayment, "trigger").mockReturnValue({
+      using _paymentSpy = vi.spyOn(processPayment, "start").mockReturnValue({
         transactionId: "txn-order-2",
         amount: 200,
         status: "completed" as const,
       });
-      using _confirmSpy = vi.spyOn(sendConfirmation, "trigger").mockReturnValue({
+      using _confirmSpy = vi.spyOn(sendConfirmation, "start").mockReturnValue({
         orderId: "order-2",
         transactionId: "txn-order-2",
         confirmed: true,
       });
 
-      const result = await workflow.mainJob.body({ orderId: "order-2", amount: 200 }, { env: {} });
+      const result = await workflow.mainJob.body(
+        { orderId: "order-2", amount: 200 },
+        { env: {}, invoker: null },
+      );
 
       expect(result).toEqual({
         orderId: "order-2",

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

@@ -35,7 +35,7 @@ export const sendConfirmation = createWorkflowJob({
 export const fulfillOrder = createWorkflowJob({
   name: "fulfill-order",
   body: (input: { orderId: string; amount: number }) => {
-    const validation = validateOrder.trigger({
+    const validation = validateOrder.start({
       orderId: input.orderId,
       amount: input.amount,
     });
@@ -44,12 +44,12 @@ export const fulfillOrder = createWorkflowJob({
       throw new Error("Order validation failed");
     }
 
-    const payment = processPayment.trigger({
+    const payment = processPayment.start({
       orderId: input.orderId,
       amount: input.amount,
     });
 
-    const confirmation = sendConfirmation.trigger({
+    const confirmation = sendConfirmation.start({
       orderId: input.orderId,
       transactionId: payment.transactionId,
     });

package/templates/workflow/tailor.d.ts

@@ -1,9 +1,9 @@
 // This file is auto-generated by @tailor-platform/sdk
 // Do not edit this file manually
-// Regenerated automatically when running 'tailor-sdk deploy' or 'tailor-sdk generate'
+// Regenerated automatically when running 'tailor deploy' or 'tailor generate'
 
 declare module "@tailor-platform/sdk" {
-  interface AttributeMap {
+  interface Attributes {
     role: string;
   }
   interface AttributeList {
@@ -14,6 +14,8 @@ declare module "@tailor-platform/sdk" {
     admin: true;
   }
   interface IdpNameRegistry {}
+  interface ConnectionNameRegistry {}
+  interface AIGatewayNameRegistry {}
 }
 
 export {};