@tailor-platform/create-sdk 0.0.1 → 0.8.1

package/templates/testing/e2e/globalSetup.ts

@@ -0,0 +1,65 @@
+import {
+  apply,
+  machineUserToken,
+  show,
+  workspaceCreate,
+  workspaceDelete,
+  type WorkspaceInfo,
+} from "@tailor-platform/sdk/cli";
+import type { TestProject } from "vitest/node";
+
+declare module "vitest" {
+  export interface ProvidedContext {
+    url: string;
+    token: string;
+  }
+}
+
+let createdWorkspace: WorkspaceInfo | null = null;
+
+async function createWorkspace(name: string, region: string) {
+  console.log(`Creating workspace "${name}" in region "${region}"...`);
+  const workspace = await workspaceCreate({ name, region });
+  console.log(`Workspace "${workspace.name}" created successfully.`);
+  return workspace;
+}
+
+async function deployApplication() {
+  console.log("Deploying application...");
+  await apply();
+  console.log("Application deployed successfully.");
+}
+
+async function deleteWorkspace(workspaceId: string) {
+  console.log("Deleting workspace...");
+  await workspaceDelete({ workspaceId });
+  console.log("Workspace deleted successfully.");
+}
+
+export async function setup(project: TestProject) {
+  const isCI = process.env.CI === "true";
+  if (isCI) {
+    const workspaceName = process.env.TAILOR_PLATFORM_WORKSPACE_NAME;
+    const workspaceRegion = process.env.TAILOR_PLATFORM_WORKSPACE_REGION;
+    if (!workspaceName || !workspaceRegion) {
+      throw new Error(
+        "TAILOR_PLATFORM_WORKSPACE_NAME and TAILOR_PLATFORM_WORKSPACE_REGION must be set when CI=true",
+      );
+    }
+    createdWorkspace = await createWorkspace(workspaceName, workspaceRegion);
+    process.env.TAILOR_PLATFORM_WORKSPACE_ID = createdWorkspace.id;
+    await deployApplication();
+  }
+
+  const app = await show();
+  const tokens = await machineUserToken({ name: "admin" });
+  project.provide("url", app.url);
+  project.provide("token", tokens.accessToken);
+}
+
+export async function teardown() {
+  if (createdWorkspace) {
+    await deleteWorkspace(createdWorkspace.id);
+    createdWorkspace = null;
+  }
+}

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

@@ -0,0 +1,57 @@
+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/eslint.config.js

@@ -0,0 +1,27 @@
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+import { defineConfig, globalIgnores } from "eslint/config";
+
+export default defineConfig([
+  // Ignore sdk's output directory.
+  globalIgnores([".tailor-sdk/", "src/generated/"]),
+  // Use recommended rules.
+  // https://typescript-eslint.io/users/configs#projects-with-type-checking
+  eslint.configs.recommended,
+  tseslint.configs.recommendedTypeChecked,
+  tseslint.configs.stylisticTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+  // Disable type-checked linting for root config files.
+  // https://typescript-eslint.io/troubleshooting/typed-linting/#how-do-i-disable-type-checked-linting-for-a-file
+  {
+    files: ["eslint.config.js"],
+    extends: [tseslint.configs.disableTypeChecked],
+  },
+]);

package/templates/testing/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "testing",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "generate": "tailor-sdk generate",
+    "deploy": "tailor-sdk apply",
+    "test": "vitest --project unit",
+    "test:unit": "vitest --project unit",
+    "test:e2e": "vitest --project e2e",
+    "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",
+    "graphql-request": "7.3.1",
+    "prettier": "3.6.2",
+    "typescript": "5.9.3",
+    "typescript-eslint": "8.46.3",
+    "vitest": "4.0.8"
+  }
+}

package/templates/testing/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/testing/src/generated/db.ts

@@ -0,0 +1,28 @@
+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": {
+    User: {
+      id: Generated<string>;
+      name: string;
+      email: string;
+      age: number;
+      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/testing/src/resolver/mockTailordb.test.ts

@@ -0,0 +1,71 @@
+import { unauthenticatedTailorUser } from "@tailor-platform/sdk/test";
+import {
+  afterAll,
+  afterEach,
+  beforeAll,
+  describe,
+  expect,
+  test,
+  vi,
+} from "vitest";
+import resolver from "./mockTailordb";
+
+describe("incrementUserAge resolver", () => {
+  // Mock queryObject method to simulate database interactions
+  const mockQueryObject = vi.fn();
+  beforeAll(() => {
+    vi.stubGlobal("tailordb", {
+      Client: vi.fn(
+        class {
+          connect = vi.fn();
+          end = vi.fn();
+          queryObject = mockQueryObject;
+        },
+      ),
+    });
+  });
+  afterAll(() => {
+    vi.unstubAllGlobals();
+  });
+  afterEach(() => {
+    mockQueryObject.mockReset();
+  });
+
+  test("basic functionality", async () => {
+    // 1: Begin transaction
+    mockQueryObject.mockResolvedValueOnce({});
+    // 2: Select current age
+    mockQueryObject.mockResolvedValueOnce({
+      rows: [{ age: 30 }],
+    });
+    // 3: Update age
+    mockQueryObject.mockResolvedValueOnce({});
+    // 4: Commit transaction
+    mockQueryObject.mockResolvedValueOnce({});
+
+    const result = await resolver.body({
+      input: { email: "test@example.com" },
+      user: unauthenticatedTailorUser,
+    });
+    expect(result).toEqual({ oldAge: 30, newAge: 31 });
+    expect(mockQueryObject).toHaveBeenCalledTimes(4);
+  });
+
+  test("user not found", async () => {
+    // 1: Begin transaction
+    mockQueryObject.mockResolvedValueOnce({});
+    // 2: Select current age (no rows returned)
+    mockQueryObject.mockResolvedValueOnce({
+      rows: [],
+    });
+    // 3: Rollback transaction
+    mockQueryObject.mockResolvedValueOnce({});
+
+    const result = resolver.body({
+      input: { email: "test@example.com" },
+      user: unauthenticatedTailorUser,
+    });
+    await expect(result).rejects.toThrowError();
+    expect(mockQueryObject).toHaveBeenCalledTimes(3);
+  });
+});

package/templates/testing/src/resolver/mockTailordb.ts

@@ -0,0 +1,44 @@
+import { createResolver, t } from "@tailor-platform/sdk";
+import { getDB } from "../generated/db";
+
+const resolver = createResolver({
+  name: "incrementUserAge",
+  operation: "mutation",
+  input: {
+    email: t.string(),
+  },
+  body: async (context) => {
+    // Initialize database client
+    const db = getDB("main-db");
+
+    return await db.transaction().execute(async (trx) => {
+      // Select current age
+      const { age } = await trx
+        .selectFrom("User")
+        .where("email", "=", context.input.email)
+        .select("age")
+        .forUpdate()
+        .executeTakeFirstOrThrow();
+
+      // Increase age by 1
+      const oldAge = age;
+      const newAge = age + 1;
+
+      // Update age in database
+      await trx
+        .updateTable("User")
+        .set({ age: newAge })
+        .where("email", "=", context.input.email)
+        .execute();
+
+      // Return old and new age
+      return { oldAge, newAge };
+    });
+  },
+  output: t.object({
+    oldAge: t.int(),
+    newAge: t.int(),
+  }),
+});
+
+export default resolver;

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

@@ -0,0 +1,13 @@
+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,
+    });
+    expect(result).toBe(3);
+  });
+});

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

@@ -0,0 +1,16 @@
+import { createResolver, t } from "@tailor-platform/sdk";
+
+const resolver = createResolver({
+  name: "add",
+  operation: "query",
+  input: {
+    left: t.int(),
+    right: t.int(),
+  },
+  body: (context) => {
+    return context.input.left + context.input.right;
+  },
+  output: t.int(),
+});
+
+export default resolver;

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

@@ -0,0 +1,53 @@
+import { describe, expect, test, vi } from "vitest";
+import { DbOperations, decrementUserAge } from "./wrapTailordb";
+
+describe("decrementUserAge resolver", () => {
+  test("basic functionality", async () => {
+    // Mock database operations
+    const dbOperations = {
+      transaction: vi.fn(
+        async (fn: (ops: DbOperations) => Promise<unknown>) =>
+          await fn(dbOperations),
+      ),
+      getUser: vi
+        .fn()
+        .mockResolvedValue({ email: "test@example.com", age: 30 }),
+      updateUser: vi.fn(),
+    } as DbOperations;
+
+    const result = await decrementUserAge("test@example.com", dbOperations);
+
+    expect(result).toEqual({ oldAge: 30, newAge: 29 });
+    expect(dbOperations.transaction).toHaveBeenCalledTimes(1);
+    expect(dbOperations.getUser).toHaveBeenCalledExactlyOnceWith(
+      "test@example.com",
+      true,
+    );
+    expect(dbOperations.updateUser).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        age: 29,
+      }),
+    );
+  });
+
+  test("user not found", async () => {
+    // Mock database operations
+    const dbOperations = {
+      transaction: vi.fn(
+        async (fn: (ops: DbOperations) => Promise<unknown>) =>
+          await fn(dbOperations),
+      ),
+      getUser: vi.fn().mockRejectedValue(new Error("User not found")),
+      updateUser: vi.fn(),
+    } as DbOperations;
+
+    const result = decrementUserAge("test@example.com", dbOperations);
+
+    expect(dbOperations.transaction).toHaveBeenCalledTimes(1);
+    expect(dbOperations.getUser).toHaveBeenCalledExactlyOnceWith(
+      "test@example.com",
+      true,
+    );
+    await expect(result).rejects.toThrowError();
+  });
+});

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

@@ -0,0 +1,80 @@
+import { createResolver, t } from "@tailor-platform/sdk";
+import { Selectable } from "kysely";
+import { getDB, type DB, type Namespace } from "../generated/db";
+
+export interface DbOperations {
+  transaction: <T>(fn: (ops: DbOperations) => Promise<T>) => Promise<T>;
+
+  getUser: (
+    email: string,
+    forUpdate: boolean,
+  ) => Promise<Selectable<Namespace["main-db"]["User"]>>;
+  updateUser: (user: Selectable<Namespace["main-db"]["User"]>) => Promise<void>;
+}
+
+function createDbOperations(db: DB<"main-db">): DbOperations {
+  return {
+    transaction: async <T>(
+      fn: (ops: DbOperations) => Promise<T>,
+    ): Promise<T> => {
+      return await db.transaction().execute(async (trx) => {
+        const dbOperations = createDbOperations(trx);
+        return await fn(dbOperations);
+      });
+    },
+
+    getUser: async (email: string, forUpdate: boolean) => {
+      let query = db.selectFrom("User").where("email", "=", email).selectAll();
+      if (forUpdate) {
+        query = query.forUpdate();
+      }
+      return await query.executeTakeFirstOrThrow();
+    },
+    updateUser: async (user: Selectable<Namespace["main-db"]["User"]>) => {
+      await db
+        .updateTable("User")
+        .set({ name: user.name, age: user.age })
+        .where("email", "=", user.email)
+        .execute();
+    },
+  };
+}
+
+export async function decrementUserAge(
+  email: string,
+  dbOperations: DbOperations,
+) {
+  return await dbOperations.transaction(async (ops) => {
+    // Select user
+    const user = await ops.getUser(email, true);
+
+    // Decrease age by 1
+    const oldAge = user.age;
+    const newAge = user.age - 1;
+
+    // Update user
+    await ops.updateUser({ ...user, age: newAge });
+
+    // Return old and new age
+    return { oldAge, newAge };
+  });
+}
+
+export default createResolver({
+  name: "decrementUserAge",
+  operation: "mutation",
+  input: {
+    email: t.string(),
+  },
+  body: async (context) => {
+    // Initialize database client
+    const db = getDB("main-db");
+    const dbOperations = createDbOperations(db);
+
+    return await decrementUserAge(context.input.email, dbOperations);
+  },
+  output: t.object({
+    oldAge: t.int(),
+    newAge: t.int(),
+  }),
+});

package/templates/testing/tailor.config.ts

@@ -0,0 +1,23 @@
+import {
+  defineAuth,
+  defineConfig,
+  defineGenerators,
+} from "@tailor-platform/sdk";
+
+export default defineConfig({
+  name: "testing",
+  auth: defineAuth("main-auth", {
+    machineUsers: {
+      admin: {
+        attributes: {},
+      },
+    },
+  }),
+  db: { "main-db": { files: ["./src/db/*.ts"] } },
+  resolver: { "main-resolver": { files: ["./src/resolver/*.ts"] } },
+});
+
+export const generators = defineGenerators([
+  "@tailor-platform/kysely-type",
+  { distPath: "./src/generated/db.ts" },
+]);

package/templates/testing/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/testing/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    watch: false,
+    projects: [
+      {
+        test: {
+          name: { label: "unit", color: "blue" },
+          include: ["src/**/*.test.ts"],
+        },
+      },
+      {
+        test: {
+          name: { label: "e2e", color: "green" },
+          include: ["e2e/**/*.test.ts"],
+          globalSetup: "e2e/globalSetup.ts",
+        },
+      },
+    ],
+  },
+});