Quickstart

Create and deploy your first Tailor Platform application in under 5 minutes

Get started in minutes

This quickstart will guide you through creating, deploying, and querying your first Tailor Platform application. You’ll have a working GraphQL API running in the cloud in under 5 minutes.

Prerequisites

1. Install Node.js

   The SDK requires Node.js 22 or later. Install Node.js via your package manager by following the official Node.js instructions.

   Verify your installation:

   node --version
   # Should output v22.0.0 or higher
   
2. Get a Tailor Platform account

   You’ll need a Tailor Platform account to deploy your application. Request access here to get started.

Create your first application

1. Create a new project

   Use the create command to scaffold a new project with the hello-world template:

   npm

   npm create @tailor-platform/sdk -- --template hello-world my-app
   

   This creates a new directory called my-app with:

   • A simple “hello” query resolver
   • TypeScript configuration
   • Database schema with a User type
   • All necessary dependencies
2. Navigate to your project

   cd my-app
   
3. Login to Tailor Platform

   Authenticate with the Tailor Platform:

   npx tailor-sdk login
   

   This will open your browser to complete the authentication flow.

4. Create a workspace

   Every application needs a workspace. Create one with the following command:

   npx tailor-sdk workspace create --name my-workspace --region us-east-1
   

   Available regions: us-east-1, eu-west-1, ap-northeast-1

   List your workspaces to get the workspace ID:

   npx tailor-sdk workspace list
   

   Alternatively, create a workspace using the Tailor Platform Console.

5. Deploy your application

   Deploy your application to your workspace:

   npm

   npm run deploy -- --workspace-id <your-workspace-id>
   

   Save your workspace ID in an .env file:

   TAILOR_PLATFORM_WORKSPACE_ID=your-workspace-id
   

   Then you can run npm run deploy without the --workspace-id flag.

   The deployment process will:

   • Build your TypeScript configuration
   • Generate type definitions
   • Deploy your database schema
   • Deploy your resolver
   • Output a GraphQL endpoint URL

Query your API

1. Open GraphQL Playground

   After deployment, you’ll receive a GraphQL endpoint URL. Open the GraphQL Playground in your browser.

2. Execute your first query

   Run the hello query with a name parameter:

   query {
     hello(name: "sdk") {
       message
     }
   }
   

   You should see the response:

   {
     "data": {
       "hello": {
         "message": "Hello, sdk!"
       }
     }
   }
   

Understanding the code

Let’s look at what you just deployed. The hello-world template includes:

Configuration file

The tailor.config.ts file defines your application:

tailor.config.ts

import { defineConfig, definePlugins } from "@tailor-platform/sdk";
import { kyselyTypePlugin } from "@tailor-platform/sdk/plugin/kysely-type";

export default defineConfig({
  name: "hello-world",
  db: { "main-db": { files: [`./src/db/*.ts`] } },
  resolver: { "main-resolver": { files: [`./src/resolvers/**/*.ts`] } },
});

export const plugins = definePlugins(
  kyselyTypePlugin({ distPath: `./src/generated/kysely-tailordb.ts` }),
);

Database schema

The src/db/user.ts file defines a User type:

src/db/user.ts

import {
  db,
  unsafeAllowAllGqlPermission,
  unsafeAllowAllTypePermission,
} from "@tailor-platform/sdk";

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(),
  })
  .features({
    gqlOperations: "query",
  })
  .permission(unsafeAllowAllTypePermission)
  .gqlPermission(unsafeAllowAllGqlPermission);

Resolver

The src/resolvers/hello.ts file defines a custom GraphQL query:

src/resolvers/hello.ts

import { createResolver, t } from "@tailor-platform/sdk";

export default createResolver({
  name: "hello",
  operation: "query",
  input: {
    name: t.string().description("Name to greet"),
  },
  body: (context) => {
    return {
      message: `Hello, ${context.input.name}!`,
    };
  },
  output: t
    .object({
      message: t.string().description("Greeting message"),
    })
    .description("Greeting response"),
});

Make your first change

1. Edit the resolver

   Open src/resolvers/hello.ts and change the message:

   src/resolvers/hello.ts

   export default createResolver({
     name: "hello",
     operation: "query",
     input: {
       name: t.string().description("Name to greet"),
     },
     body: (context) => {
       return {
         message: `Welcome to Tailor Platform, ${context.input.name}!`,
       };
     },
     output: t
       .object({
         message: t.string().description("Greeting message"),
       })
       .description("Greeting response"),
   });
   
2. Deploy your changes

   npm run deploy
   
3. Test the updated query

   Run the same GraphQL query and see the updated response:

   query {
     hello(name: "sdk") {
       message
     }
   }
   

   {
     "data": {
       "hello": {
         "message": "Welcome to Tailor Platform, sdk!"
       }
     }
   }
   

Next steps

Congratulations! You’ve created, deployed, and modified your first Tailor Platform application.

Learn about TailorDB

Define complex database schemas with relationships and permissions

Create custom resolvers

Build GraphQL resolvers with business logic and database access

Set up executors

React to events like database changes and webhooks

Explore templates

Check out the inventory-management and testing templates for more examples