@tailor-platform/create-sdk 1.20.0 → 1.21.0

package/templates/workflow/.oxlintrc.json

@@ -0,0 +1,197 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "plugins": ["typescript"],
+  "categories": {
+    "correctness": "off"
+  },
+  "env": {
+    "builtin": true
+  },
+  "ignorePatterns": [".tailor-sdk/", "src/generated/"],
+  "rules": {
+    "constructor-super": "error",
+    "for-direction": "error",
+    "no-async-promise-executor": "error",
+    "no-case-declarations": "error",
+    "no-class-assign": "error",
+    "no-compare-neg-zero": "error",
+    "no-cond-assign": "error",
+    "no-const-assign": "error",
+    "no-constant-binary-expression": "error",
+    "no-constant-condition": "error",
+    "no-control-regex": "error",
+    "no-debugger": "error",
+    "no-delete-var": "error",
+    "no-dupe-class-members": "error",
+    "no-dupe-else-if": "error",
+    "no-dupe-keys": "error",
+    "no-duplicate-case": "error",
+    "no-empty": "error",
+    "no-empty-character-class": "error",
+    "no-empty-pattern": "error",
+    "no-empty-static-block": "error",
+    "no-ex-assign": "error",
+    "no-extra-boolean-cast": "error",
+    "no-fallthrough": "error",
+    "no-func-assign": "error",
+    "no-global-assign": "error",
+    "no-import-assign": "error",
+    "no-invalid-regexp": "error",
+    "no-irregular-whitespace": "error",
+    "no-loss-of-precision": "error",
+    "no-new-native-nonconstructor": "error",
+    "no-nonoctal-decimal-escape": "error",
+    "no-obj-calls": "error",
+    "no-prototype-builtins": "error",
+    "no-redeclare": "error",
+    "no-regex-spaces": "error",
+    "no-self-assign": "error",
+    "no-setter-return": "error",
+    "no-shadow-restricted-names": "error",
+    "no-sparse-arrays": "error",
+    "no-this-before-super": "error",
+    "no-unexpected-multiline": "error",
+    "no-unsafe-finally": "error",
+    "no-unsafe-negation": "error",
+    "no-unsafe-optional-chaining": "error",
+    "no-unused-labels": "error",
+    "no-unused-private-class-members": "error",
+    "no-unused-vars": "error",
+    "no-useless-backreference": "error",
+    "no-useless-catch": "error",
+    "no-useless-escape": "error",
+    "no-with": "error",
+    "require-yield": "error",
+    "use-isnan": "error",
+    "valid-typeof": "error",
+    "@typescript-eslint/await-thenable": "error",
+    "@typescript-eslint/ban-ts-comment": "error",
+    "no-array-constructor": "error",
+    "@typescript-eslint/no-array-delete": "error",
+    "@typescript-eslint/no-base-to-string": "error",
+    "@typescript-eslint/no-duplicate-enum-values": "error",
+    "@typescript-eslint/no-duplicate-type-constituents": "error",
+    "@typescript-eslint/no-empty-object-type": "error",
+    "@typescript-eslint/no-explicit-any": "error",
+    "@typescript-eslint/no-extra-non-null-assertion": "error",
+    "@typescript-eslint/no-floating-promises": "error",
+    "@typescript-eslint/no-for-in-array": "error",
+    "@typescript-eslint/no-implied-eval": "error",
+    "@typescript-eslint/no-misused-new": "error",
+    "@typescript-eslint/no-misused-promises": "error",
+    "@typescript-eslint/no-namespace": "error",
+    "@typescript-eslint/no-non-null-asserted-optional-chain": "error",
+    "@typescript-eslint/no-redundant-type-constituents": "error",
+    "@typescript-eslint/no-require-imports": "error",
+    "@typescript-eslint/no-this-alias": "error",
+    "@typescript-eslint/no-unnecessary-type-assertion": "error",
+    "@typescript-eslint/no-unnecessary-type-constraint": "error",
+    "@typescript-eslint/no-unsafe-argument": "error",
+    "@typescript-eslint/no-unsafe-assignment": "error",
+    "@typescript-eslint/no-unsafe-call": "error",
+    "@typescript-eslint/no-unsafe-declaration-merging": "error",
+    "@typescript-eslint/no-unsafe-enum-comparison": "error",
+    "@typescript-eslint/no-unsafe-function-type": "error",
+    "@typescript-eslint/no-unsafe-member-access": "error",
+    "@typescript-eslint/no-unsafe-return": "error",
+    "@typescript-eslint/no-unsafe-unary-minus": "error",
+    "no-unused-expressions": "error",
+    "@typescript-eslint/no-wrapper-object-types": "error",
+    "@typescript-eslint/only-throw-error": "error",
+    "@typescript-eslint/prefer-as-const": "error",
+    "@typescript-eslint/prefer-namespace-keyword": "error",
+    "@typescript-eslint/prefer-promise-reject-errors": "error",
+    "@typescript-eslint/require-await": "error",
+    "@typescript-eslint/restrict-plus-operands": "error",
+    "@typescript-eslint/restrict-template-expressions": "error",
+    "@typescript-eslint/triple-slash-reference": "error",
+    "@typescript-eslint/unbound-method": "error",
+    "@typescript-eslint/adjacent-overload-signatures": "error",
+    "@typescript-eslint/array-type": "error",
+    "@typescript-eslint/ban-tslint-comment": "error",
+    "@typescript-eslint/consistent-generic-constructors": "error",
+    "@typescript-eslint/consistent-indexed-object-style": "error",
+    "@typescript-eslint/consistent-type-definitions": "error",
+    "@typescript-eslint/no-confusing-non-null-assertion": "error",
+    "no-empty-function": "error",
+    "@typescript-eslint/no-inferrable-types": "error",
+    "@typescript-eslint/non-nullable-type-assertion-style": "error",
+    "@typescript-eslint/prefer-for-of": "error",
+    "@typescript-eslint/prefer-function-type": "error",
+    "@typescript-eslint/prefer-includes": "error",
+    "@typescript-eslint/prefer-nullish-coalescing": "error"
+  },
+  "overrides": [
+    {
+      "files": ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
+      "rules": {
+        "constructor-super": "off",
+        "no-class-assign": "off",
+        "no-const-assign": "off",
+        "no-dupe-class-members": "off",
+        "no-dupe-keys": "off",
+        "no-func-assign": "off",
+        "no-import-assign": "off",
+        "no-new-native-nonconstructor": "off",
+        "no-obj-calls": "off",
+        "no-redeclare": "off",
+        "no-setter-return": "off",
+        "no-this-before-super": "off",
+        "no-unsafe-negation": "off",
+        "no-var": "error",
+        "no-with": "off",
+        "prefer-rest-params": "error",
+        "prefer-spread": "error"
+      }
+    },
+    {
+      "files": ["eslint.config.js"],
+      "rules": {
+        "@typescript-eslint/await-thenable": "off",
+        "@typescript-eslint/no-array-delete": "off",
+        "@typescript-eslint/no-base-to-string": "off",
+        "@typescript-eslint/no-confusing-void-expression": "off",
+        "@typescript-eslint/no-deprecated": "off",
+        "@typescript-eslint/no-duplicate-type-constituents": "off",
+        "@typescript-eslint/no-floating-promises": "off",
+        "@typescript-eslint/no-for-in-array": "off",
+        "@typescript-eslint/no-implied-eval": "off",
+        "@typescript-eslint/no-meaningless-void-operator": "off",
+        "@typescript-eslint/no-misused-promises": "off",
+        "@typescript-eslint/no-misused-spread": "off",
+        "@typescript-eslint/no-mixed-enums": "off",
+        "@typescript-eslint/no-redundant-type-constituents": "off",
+        "@typescript-eslint/no-unnecessary-boolean-literal-compare": "off",
+        "@typescript-eslint/no-unnecessary-template-expression": "off",
+        "@typescript-eslint/no-unnecessary-type-arguments": "off",
+        "@typescript-eslint/no-unnecessary-type-assertion": "off",
+        "@typescript-eslint/no-unsafe-argument": "off",
+        "@typescript-eslint/no-unsafe-assignment": "off",
+        "@typescript-eslint/no-unsafe-call": "off",
+        "@typescript-eslint/no-unsafe-enum-comparison": "off",
+        "@typescript-eslint/no-unsafe-member-access": "off",
+        "@typescript-eslint/no-unsafe-return": "off",
+        "@typescript-eslint/no-unsafe-type-assertion": "off",
+        "@typescript-eslint/no-unsafe-unary-minus": "off",
+        "@typescript-eslint/non-nullable-type-assertion-style": "off",
+        "@typescript-eslint/only-throw-error": "off",
+        "@typescript-eslint/prefer-includes": "off",
+        "@typescript-eslint/prefer-nullish-coalescing": "off",
+        "@typescript-eslint/prefer-promise-reject-errors": "off",
+        "@typescript-eslint/prefer-reduce-type-parameter": "off",
+        "@typescript-eslint/prefer-return-this-type": "off",
+        "@typescript-eslint/promise-function-async": "off",
+        "@typescript-eslint/related-getter-setter-pairs": "off",
+        "@typescript-eslint/require-array-sort-compare": "off",
+        "@typescript-eslint/require-await": "off",
+        "@typescript-eslint/restrict-plus-operands": "off",
+        "@typescript-eslint/restrict-template-expressions": "off",
+        "@typescript-eslint/return-await": "off",
+        "@typescript-eslint/strict-boolean-expressions": "off",
+        "@typescript-eslint/switch-exhaustiveness-check": "off",
+        "@typescript-eslint/unbound-method": "off",
+        "@typescript-eslint/use-unknown-in-catch-callback-variable": "off"
+      }
+    }
+  ]
+}

package/templates/workflow/.prettierrc

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

package/templates/workflow/README.md

@@ -0,0 +1,25 @@
+# Workflow Template
+
+Demonstrates workflow patterns with job chaining, trigger testing, and dependency injection.
+
+## Features
+
+- Workflow with multiple jobs (`createWorkflow`, `createWorkflowJob`)
+- Job chaining via `.trigger()`
+- User context access in jobs
+- Database operations in workflow jobs (DI pattern)
+- Integration testing with `WORKFLOW_TEST_ENV_KEY` / `WORKFLOW_TEST_USER_KEY`
+
+## Getting Started
+
+```bash
+pnpm install
+pnpm generate
+pnpm deploy
+```
+
+## Testing
+
+```bash
+pnpm test
+```

package/templates/workflow/__dot__gitignore

@@ -0,0 +1,3 @@
+node_modules/
+.tailor-sdk/
+.eslintcache

package/templates/{testing → workflow}/e2e/globalSetup.ts

@@ -17,26 +17,26 @@ declare module "vitest" {
 
 let createdWorkspace: WorkspaceInfo | null = null;
 
-async function setupWorkspace(name: string, region: string) {
+async function setupWorkspace(name: string, region: string): Promise<WorkspaceInfo> {
   console.log(`Creating workspace "${name}" in region "${region}"...`);
   const workspace = await createWorkspace({ name, region });
   console.log(`Workspace "${workspace.name}" created successfully.`);
   return workspace;
 }
 
-async function deployApplication() {
+async function deployApplication(): Promise<void> {
   console.log("Deploying application...");
   await apply();
   console.log("Application deployed successfully.");
 }
 
-async function cleanupWorkspace(workspaceId: string) {
+async function cleanupWorkspace(workspaceId: string): Promise<void> {
   console.log("Deleting workspace...");
   await deleteWorkspace({ workspaceId });
   console.log("Workspace deleted successfully.");
 }
 
-export async function setup(project: TestProject) {
+export async function setup(project: TestProject): Promise<void> {
   const isCI = process.env.CI === "true";
   if (isCI) {
     const workspaceName = process.env.TAILOR_PLATFORM_WORKSPACE_NAME;
@@ -57,7 +57,7 @@ export async function setup(project: TestProject) {
   project.provide("token", tokens.accessToken);
 }
 
-export async function teardown() {
+export async function teardown(): Promise<void> {
   if (createdWorkspace) {
     await cleanupWorkspace(createdWorkspace.id);
     createdWorkspace = null;

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

@@ -0,0 +1,90 @@
+import { randomUUID } from "node:crypto";
+import { gql, GraphQLClient } from "graphql-request";
+import { describe, expect, inject, test } from "vitest";
+
+function createGraphQLClient(): GraphQLClient {
+  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.sequential("incrementAge", () => {
+    const uuid = randomUUID();
+    const testEmail = `alice-${uuid}@example.com`;
+
+    test("create test user", async () => {
+      const query = gql`
+        mutation ($input: UserCreateInput!) {
+          createUser(input: $input) {
+            id
+          }
+        }
+      `;
+      const result = await graphQLClient.rawRequest(query, {
+        input: { name: "alice", email: testEmail, age: 30 },
+      });
+      expect(result.errors).toBeUndefined();
+    });
+
+    test("increment age returns old and new values", async () => {
+      const query = gql`
+        mutation ($email: String!) {
+          incrementAge(email: $email) {
+            oldAge
+            newAge
+          }
+        }
+      `;
+      const result = await graphQLClient.rawRequest(query, { email: testEmail });
+      expect(result.errors).toBeUndefined();
+      expect(result.data).toEqual({
+        incrementAge: {
+          oldAge: 30,
+          newAge: 31,
+        },
+      });
+    });
+
+    test("increment is idempotent per call", async () => {
+      const query = gql`
+        mutation ($email: String!) {
+          incrementAge(email: $email) {
+            oldAge
+            newAge
+          }
+        }
+      `;
+      const result = await graphQLClient.rawRequest(query, { email: testEmail });
+      expect(result.errors).toBeUndefined();
+      expect(result.data).toEqual({
+        incrementAge: {
+          oldAge: 31,
+          newAge: 32,
+        },
+      });
+    });
+  });
+
+  test("incrementAge fails for non-existent user", async () => {
+    const query = gql`
+      mutation ($email: String!) {
+        incrementAge(email: $email) {
+          oldAge
+          newAge
+        }
+      }
+    `;
+    const result = await graphQLClient.rawRequest(query, {
+      email: "non-existent@example.com",
+    });
+    expect(result.errors).toBeDefined();
+  });
+});

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

@@ -0,0 +1,31 @@
+import { randomUUID } from "node:crypto";
+import { describe, expect, test } from "vitest";
+import { startWorkflow } from "@tailor-platform/sdk/cli";
+import config from "../tailor.config";
+import userProfileSyncWorkflow from "../src/workflow/sync-profile";
+
+describe("workflow", () => {
+  test("user-profile-sync: execute db-backed workflow", { 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",
+    });
+    expect(result.jobExecutions).toBe(1);
+  });
+});

package/templates/workflow/eslint.config.js

@@ -0,0 +1,24 @@
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+import { defineConfig, globalIgnores } from "eslint/config";
+import oxlint from "eslint-plugin-oxlint";
+
+export default defineConfig([
+  globalIgnores([".tailor-sdk/", "src/generated/"]),
+  eslint.configs.recommended,
+  tseslint.configs.recommendedTypeChecked,
+  tseslint.configs.stylisticTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  {
+    files: ["eslint.config.js"],
+    extends: [tseslint.configs.disableTypeChecked],
+  },
+  ...oxlint.buildFromOxlintConfigFile("./.oxlintrc.json"),
+]);

package/templates/{testing → workflow}/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "testing",
+  "name": "workflow",
   "private": true,
   "type": "module",
   "scripts": {
@@ -17,10 +17,11 @@
   "devDependencies": {
     "@eslint/js": "9.39.2",
     "@tailor-platform/function-types": "0.8.0",
-    "@tailor-platform/sdk": "1.20.0",
+    "@tailor-platform/sdk": "1.21.0",
     "@types/node": "24.10.9",
     "eslint": "9.39.2",
     "eslint-plugin-oxlint": "1.39.0",
+    "graphql": "16.12.0",
     "graphql-request": "7.4.0",
     "oxfmt": "0.24.0",
     "oxlint": "1.39.0",

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

@@ -0,0 +1,22 @@
+import { db } from "@tailor-platform/sdk";
+
+export const order = db
+  .type("Order", {
+    customerName: db.string(),
+    amount: db.int(),
+    status: db.enum(["PENDING", "PROCESSING", "COMPLETED", "FAILED"]),
+    ...db.fields.timestamps(),
+  })
+  .permission({
+    create: [[{ user: "_loggedIn" }, "=", true]],
+    read: [[{ user: "_loggedIn" }, "=", true]],
+    update: [[{ user: "_loggedIn" }, "=", true]],
+    delete: [[{ user: "_loggedIn" }, "=", true]],
+  })
+  .gqlPermission([
+    {
+      conditions: [[{ user: "_loggedIn" }, "=", true]],
+      actions: "all",
+      permit: true,
+    },
+  ]);

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

@@ -0,0 +1,22 @@
+import { db } from "@tailor-platform/sdk";
+
+export const user = db
+  .type("User", {
+    name: db.string(),
+    email: db.string().unique(),
+    age: db.int(),
+    ...db.fields.timestamps(),
+  })
+  .permission({
+    create: [[{ user: "_loggedIn" }, "=", true]],
+    read: [[{ user: "_loggedIn" }, "=", true]],
+    update: [[{ user: "_loggedIn" }, "=", true]],
+    delete: [[{ user: "_loggedIn" }, "=", true]],
+  })
+  .gqlPermission([
+    {
+      conditions: [[{ user: "_loggedIn" }, "=", true]],
+      actions: "all",
+      permit: true,
+    },
+  ]);

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

@@ -0,0 +1,48 @@
+import {
+  createGetDB,
+  type Generated,
+  type Timestamp,
+  type NamespaceDB,
+  type NamespaceInsertable,
+  type NamespaceSelectable,
+  type NamespaceTable,
+  type NamespaceTableName,
+  type NamespaceTransaction,
+  type NamespaceUpdateable,
+} from "@tailor-platform/sdk/kysely";
+
+export interface Namespace {
+  "main-db": {
+    Order: {
+      id: Generated<string>;
+      customerName: string;
+      amount: number;
+      status: "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED";
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    User: {
+      id: Generated<string>;
+      name: string;
+      email: string;
+      age: number;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+  }
+}
+
+export const getDB = createGetDB<Namespace>();
+
+export type DB<N extends keyof Namespace = keyof Namespace> = NamespaceDB<Namespace, N>;
+
+export type Transaction<K extends keyof Namespace | DB = keyof Namespace> =
+  NamespaceTransaction<Namespace, K>;
+
+type TableName = NamespaceTableName<Namespace>;
+export type Table<T extends TableName> = NamespaceTable<Namespace, T>;
+
+export type Insertable<T extends TableName> = NamespaceInsertable<Namespace, T>;
+export type Selectable<T extends TableName> = NamespaceSelectable<Namespace, T>;
+export type Updateable<T extends TableName> = NamespaceUpdateable<Namespace, T>;

package/templates/workflow/src/resolver/incrementAge.ts

@@ -0,0 +1,40 @@
+import { createResolver, t } from "@tailor-platform/sdk";
+import { getDB } from "../generated/db";
+
+const resolver = createResolver({
+  name: "incrementAge",
+  description: "Increment age of a user by email",
+  operation: "mutation",
+  input: {
+    email: t.string(),
+  },
+  body: async (context) => {
+    const db = getDB("main-db");
+
+    return await db.transaction().execute(async (trx) => {
+      const { age } = await trx
+        .selectFrom("User")
+        .where("email", "=", context.input.email)
+        .select("age")
+        .forUpdate()
+        .executeTakeFirstOrThrow();
+
+      const oldAge = age;
+      const newAge = age + 1;
+
+      await trx
+        .updateTable("User")
+        .set({ age: newAge })
+        .where("email", "=", context.input.email)
+        .execute();
+
+      return { oldAge, newAge };
+    });
+  },
+  output: t.object({
+    oldAge: t.int(),
+    newAge: t.int(),
+  }),
+});
+
+export default resolver;