@tailor-platform/create-sdk 0.0.1 → 0.8.1

package/templates/inventory-management/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "inventory-management",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "deploy": "tailor-sdk apply",
+    "generate": "tailor-sdk generate",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint --cache .",
+    "lint:fix": "eslint --cache --fix .",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@tailor-platform/function-kysely-tailordb": "0.1.3",
+    "kysely": "0.28.7"
+  },
+  "devDependencies": {
+    "@eslint/js": "9.39.1",
+    "@tailor-platform/function-types": "0.7.2",
+    "@tailor-platform/sdk": "0.8.1",
+    "@types/node": "22.19.0",
+    "eslint": "9.39.1",
+    "prettier": "3.6.2",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.46.3"
+  }
+}

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

@@ -0,0 +1,13 @@
+import { db } from "@tailor-platform/sdk";
+import { gqlPermissionManager, permissionManager } from "./common/permission";
+
+export const category = db
+  .type("Category", {
+    name: db.string().description("Name of the category").unique(),
+    description: db
+      .string({ optional: true })
+      .description("Description of the category"),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionManager)
+  .gqlPermission(gqlPermissionManager);

package/templates/inventory-management/src/db/common/permission.ts

@@ -0,0 +1,59 @@
+import type {
+  PermissionCondition,
+  TailorTypeGqlPermission,
+  TailorTypePermission,
+} from "@tailor-platform/sdk";
+
+export interface User {
+  role: string;
+}
+
+export const managerRole = [
+  { user: "role" },
+  "=",
+  "MANAGER",
+] as const satisfies PermissionCondition;
+export const loggedIn = [
+  { user: "_loggedIn" },
+  "=",
+  true,
+] as const satisfies PermissionCondition;
+
+// Manager can do anything, Staff can only read.
+export const permissionManager = {
+  create: [managerRole],
+  read: [loggedIn],
+  update: [managerRole],
+  delete: [managerRole],
+} as const satisfies TailorTypePermission;
+
+// Manager can perform any GraphQL operations, Staff can only read.
+export const gqlPermissionManager = [
+  {
+    conditions: [managerRole],
+    actions: "all",
+    permit: true,
+  },
+  {
+    conditions: [loggedIn],
+    actions: ["read"],
+    permit: true,
+  },
+] as const satisfies TailorTypeGqlPermission;
+
+// Any logged-in user can do anything.
+export const permissionLoggedIn = {
+  create: [loggedIn],
+  read: [loggedIn],
+  update: [loggedIn],
+  delete: [loggedIn],
+} as const satisfies TailorTypePermission;
+
+// Any logged-in user can perform read GraphQL operation.
+export const gqlPermissionLoggedIn = [
+  {
+    conditions: [loggedIn],
+    actions: ["read"],
+    permit: true,
+  },
+] as const satisfies TailorTypeGqlPermission;

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

@@ -0,0 +1,17 @@
+import { db } from "@tailor-platform/sdk";
+import { gqlPermissionManager, permissionManager } from "./common/permission";
+
+export const contact = db
+  .type("Contact", {
+    name: db.string().description("Name of the contact"),
+    email: db.string().unique().description("Email address of the contact"),
+    phone: db
+      .string({ optional: true })
+      .description("Phone number of the contact"),
+    address: db
+      .string({ optional: true })
+      .description("Address of the contact"),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionManager)
+  .gqlPermission(gqlPermissionManager);

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

@@ -0,0 +1,18 @@
+import { db } from "@tailor-platform/sdk";
+import { gqlPermissionLoggedIn, permissionLoggedIn } from "./common/permission";
+import { product } from "./product";
+
+export const inventory = db
+  .type("Inventory", {
+    productId: db
+      .uuid()
+      .description("ID of the product")
+      .relation({ type: "1-1", toward: { type: product } }),
+    quantity: db
+      .int()
+      .description("Quantity of the product in inventory")
+      .validate(({ value }) => value >= 0),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionLoggedIn)
+  .gqlPermission(gqlPermissionLoggedIn);

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

@@ -0,0 +1,21 @@
+import { db } from "@tailor-platform/sdk";
+import { loggedIn, managerRole, permissionManager } from "./common/permission";
+
+export const notification = db
+  .type("Notification", {
+    message: db.string().description("Notification message"),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionManager)
+  .gqlPermission([
+    {
+      conditions: [managerRole],
+      actions: ["delete"],
+      permit: true,
+    },
+    {
+      conditions: [loggedIn],
+      actions: ["read"],
+      permit: true,
+    },
+  ]);

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

@@ -0,0 +1,20 @@
+import { db } from "@tailor-platform/sdk";
+import { contact } from "./contact";
+import { gqlPermissionLoggedIn, permissionLoggedIn } from "./common/permission";
+
+export const order = db
+  .type("Order", {
+    name: db.string().description("Name of the order"),
+    description: 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"),
+    contactId: db
+      .uuid()
+      .description("Contact associated with the order")
+      .relation({ type: "n-1", toward: { type: contact } }),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionLoggedIn)
+  .gqlPermission(gqlPermissionLoggedIn);

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

@@ -0,0 +1,36 @@
+import { db } from "@tailor-platform/sdk";
+import { order } from "./order";
+import { product } from "./product";
+import { gqlPermissionLoggedIn, permissionLoggedIn } from "./common/permission";
+
+export const orderItem = db
+  .type("OrderItem", {
+    orderId: db
+      .uuid()
+      .description("ID of the order")
+      .relation({ type: "n-1", toward: { type: order } }),
+    productId: db
+      .uuid()
+      .description("ID of the product")
+      .relation({ type: "n-1", toward: { type: product } }),
+    quantity: db
+      .int()
+      .description("Quantity of the product")
+      .validate(({ value }) => value >= 0),
+    unitPrice: db
+      .float()
+      .description("Unit price of the product")
+      .validate(({ value }) => value >= 0),
+    totalPrice: db
+      .float({ optional: true, assertNonNull: true })
+      .description("Total price of the order item"),
+    ...db.fields.timestamps(),
+  })
+  .hooks({
+    totalPrice: {
+      create: ({ data }) => (data?.quantity ?? 0) * (data.unitPrice ?? 0),
+      update: ({ data }) => (data?.quantity ?? 0) * (data.unitPrice ?? 0),
+    },
+  })
+  .permission(permissionLoggedIn)
+  .gqlPermission(gqlPermissionLoggedIn);

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

@@ -0,0 +1,18 @@
+import { db } from "@tailor-platform/sdk";
+import { category } from "./category";
+import { gqlPermissionManager, permissionManager } from "./common/permission";
+
+export const product = db
+  .type("Product", {
+    name: db.string().description("Name of the product"),
+    description: db
+      .string({ optional: true })
+      .description("Description of the product"),
+    categoryId: db
+      .uuid()
+      .description("ID of the category the product belongs to")
+      .relation({ type: "n-1", toward: { type: category } }),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionManager)
+  .gqlPermission(gqlPermissionManager);

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

@@ -0,0 +1,12 @@
+import { db } from "@tailor-platform/sdk";
+import { gqlPermissionManager, permissionManager } from "./common/permission";
+
+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"),
+    ...db.fields.timestamps(),
+  })
+  .permission(permissionManager)
+  .gqlPermission(gqlPermissionManager);

package/templates/inventory-management/src/executor/checkInventory.ts

@@ -0,0 +1,28 @@
+import { createExecutor, recordUpdatedTrigger } from "@tailor-platform/sdk";
+import { inventory } from "../db/inventory";
+import config from "../../tailor.config";
+import { getDB } from "../generated/kysely-tailordb";
+
+export default createExecutor({
+  name: "check-inventory",
+  description: "Notify when inventory drops below threshold",
+  trigger: recordUpdatedTrigger({
+    type: inventory,
+    condition: ({ oldRecord, newRecord }) =>
+      oldRecord.quantity >= 10 && newRecord.quantity < 10,
+  }),
+  operation: {
+    kind: "function",
+    body: async ({ newRecord }) => {
+      const db = getDB("main-db");
+
+      await db
+        .insertInto("Notification")
+        .values({
+          message: `Inventory for product ${newRecord.productId} is below threshold. Current quantity: ${newRecord.quantity}`,
+        })
+        .execute();
+    },
+    invoker: config.auth.invoker("manager"),
+  },
+});

package/templates/inventory-management/src/generated/kysely-tailordb.ts

@@ -0,0 +1,92 @@
+import { type ColumnType, Kysely } from "kysely";
+import { TailordbDialect } from "@tailor-platform/function-kysely-tailordb";
+
+type Timestamp = ColumnType<Date, Date | string, Date | string>;
+type Generated<T> = T extends ColumnType<infer S, infer I, infer U>
+  ? ColumnType<S, I | undefined, U>
+  : ColumnType<T, T | undefined, T>;
+type Serial<T = string | number> = ColumnType<T, never, never>;
+
+export interface Namespace {
+  "main-db": {
+    Category: {
+      id: Generated<string>;
+      name: string;
+      description: string | null;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Contact: {
+      id: Generated<string>;
+      name: string;
+      email: string;
+      phone: string | null;
+      address: string | null;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Inventory: {
+      id: Generated<string>;
+      productId: string;
+      quantity: number;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Notification: {
+      id: Generated<string>;
+      message: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Order: {
+      id: Generated<string>;
+      name: string;
+      description: string | null;
+      orderDate: Timestamp;
+      orderType: "PURCHASE" | "SALES";
+      contactId: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    OrderItem: {
+      id: Generated<string>;
+      orderId: string;
+      productId: string;
+      quantity: number;
+      unitPrice: number;
+      totalPrice: Generated<number | null>;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    Product: {
+      id: Generated<string>;
+      name: string;
+      description: string | null;
+      categoryId: string;
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+
+    User: {
+      id: Generated<string>;
+      name: string;
+      email: string;
+      role: "MANAGER" | "STAFF";
+      createdAt: Generated<Timestamp>;
+      updatedAt: Timestamp | null;
+    }
+  }
+}
+
+export function getDB<const N extends keyof Namespace>(namespace: N): Kysely<Namespace[N]> {
+  const client = new tailordb.Client({ namespace });
+  return new Kysely<Namespace[N]>({ dialect: new TailordbDialect(client) });
+}
+
+export type DB<N extends keyof Namespace = keyof Namespace> = ReturnType<typeof getDB<N>>;

package/templates/inventory-management/src/pipeline/registerOrder.ts

@@ -0,0 +1,100 @@
+import { createResolver, t } from "@tailor-platform/sdk";
+import { order } from "../db/order";
+import { orderItem } from "../db/orderItem";
+import { type DB, getDB } from "../generated/kysely-tailordb";
+
+const input = {
+  order: t.object(order.omitFields(["id", "createdAt"])),
+  items: t.object(orderItem.omitFields(["id", "createdAt"]), { array: true }),
+};
+interface Input {
+  order: t.infer<typeof input.order>;
+  items: t.infer<typeof input.items>;
+}
+
+const insertOrder = async (db: DB<"main-db">, input: Input) => {
+  // Insert Order
+  const order = await db
+    .insertInto("Order")
+    .values(input.order)
+    .returning("id")
+    .executeTakeFirstOrThrow();
+
+  // Insert OrderItems
+  await db
+    .insertInto("OrderItem")
+    .values(
+      input.items.map((item) => ({
+        ...item,
+        orderId: order.id,
+      })),
+    )
+    .execute();
+};
+
+const updateInventory = async (db: DB<"main-db">, input: Input) => {
+  for (const item of input.items) {
+    const inventory = await db
+      .selectFrom("Inventory")
+      .selectAll()
+      .where("productId", "=", item.productId)
+      .forUpdate()
+      .executeTakeFirst();
+
+    // If inventory already exists, update it.
+    // Otherwise, create it (only for PURCHASE order).
+    if (inventory) {
+      let quantity: number;
+      if (input.order.orderType === "PURCHASE") {
+        quantity = inventory.quantity + item.quantity;
+      } else {
+        quantity = inventory.quantity - item.quantity;
+      }
+      if (quantity < 0) {
+        throw new Error(
+          `Cannot create order because inventory is not enough. productId: ${item.productId}`,
+        );
+      }
+      await db
+        .updateTable("Inventory")
+        .set({ quantity })
+        .where("id", "=", inventory.id)
+        .execute();
+    } else {
+      if (input.order.orderType === "PURCHASE") {
+        await db
+          .insertInto("Inventory")
+          .values({
+            productId: item.productId,
+            quantity: item.quantity,
+          })
+          .execute();
+      } else {
+        throw new Error(
+          `Cannot create order because inventory is not enough. productId: ${item.productId}`,
+        );
+      }
+    }
+  }
+};
+
+export default createResolver({
+  name: "registerOrder",
+  operation: "mutation",
+  input,
+  body: async (context) => {
+    const db = getDB("main-db");
+    await db.transaction().execute(async (trx) => {
+      await insertOrder(trx, context.input);
+      await updateInventory(trx, context.input);
+    });
+    return { success: true };
+  },
+  output: t
+    .object({
+      success: t
+        .bool()
+        .description("Whether the order was registered successfully"),
+    })
+    .description("Result of order registration"),
+});

package/templates/inventory-management/tailor.config.ts

@@ -0,0 +1,35 @@
+import {
+  defineAuth,
+  defineConfig,
+  defineGenerators,
+} from "@tailor-platform/sdk";
+import { user } from "./src/db/user";
+
+export default defineConfig({
+  name: "inventory-management",
+  db: { "main-db": { files: [`./src/db/*.ts`] } },
+  resolver: { "main-resolver": { files: [`./src/pipeline/*.ts`] } },
+  auth: defineAuth("main-auth", {
+    userProfile: {
+      type: user,
+      usernameField: "email",
+      attributes: {
+        role: true,
+      },
+    },
+    machineUsers: {
+      manager: {
+        attributes: { role: "MANAGER" },
+      },
+      staff: {
+        attributes: { role: "STAFF" },
+      },
+    },
+  }),
+  executor: { files: ["./src/executor/*.ts"] },
+});
+
+export const generators = defineGenerators([
+  "@tailor-platform/kysely-type",
+  { distPath: `./src/generated/kysely-tailordb.ts` },
+]);

package/templates/inventory-management/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": ["src/**/*", "tailor.config.ts"]
+}

package/templates/testing/.gitignore

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

package/templates/testing/.prettierignore

@@ -0,0 +1,2 @@
+src/generated/
+pnpm-lock.yaml

package/templates/testing/.prettierrc

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

package/templates/testing/README.md

@@ -0,0 +1,130 @@
+# 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                 |