The type safe
serverless platform for
modern full-stack developers

type Person = {
  firstName: string;
  lastName: string;
}

@GenezioDeploy()
class HelloWorldService {
  hello(name: string): string {
    return `Hello ${name}!`;
  }

  bye(person: Person): string {
    return `Bye, ${person.firstName} ${person.lastName}!`;
  }
}

import { HelloworldService, Person } from '@genezio-sdk/helloworld-app';

const hi = await HelloworldService.hello('John');
const person: Person = {firstName: 'John', lastName: 'Ronald'};
const bye = await HelloworldService.bye(person);

import { HelloworldService, Person } from '@genezio-sdk/helloworld-app';

async function main() {
  const hi = await HelloworldService.hello('John');
  const person: Person = {firstName: 'John', lastName: 'Ronald'};
  const bye = await HelloworldService.bye(person);
}

import 'package:hello_world/sdk/hello_world_service.dart';

void main() async {
  final hi = await HelloWorldService.hello('John');
  final person = Person(firstName: 'John', lastName: 'Ronald');
  final bye = await HelloWorldService.bye(person);
}

import sdk.HelloWorldService
import sdk.Person

suspend fun sayHi() {
  val hi = HelloWorldService().hello("John")
  val person = Person(firstName = "John", lastName = "Ronald")
  val bye = HelloWorldService().bye(person)
}

import { AuthService } from '@genezio/auth';

  AuthService.get().setTokenAndRegion("1-xyz", "us-east-1")
  
  const Signup = () => {
    // rest of the code
  
    const handleSignupSubmit = async (e) => {
      // Use the auto generated EmailAuthService to register the user
      const response = await AuthService.get().register(user.email, user.password, user.username)
      if (response.success) { ... }
    }
  
    const handleLoginSubmit = async (e) => {
      // Use the auto generated EmailAuthService to register the user
      const response = await AuthService.get().login(user.email, user.password)
      if (response.success) { ... }
    }
  
    const getUserInfo = async (e) => {
      // Use the auto generated EmailAuthService to register the user
      const userInfo = await AuthService.get().getUserInfo()
      ...
    }
    
    // rest of the code
  }

import { GenezioDeploy, GnzContext, GnzAuth } from '@genezio/types';

@GenezioDeploy()
export class UserInfoService {

  @GnzAuth
  async getUserInfo(context: GnzContext): Promise<void> {
    const userInfo = await UserModel.getUserInfo(context.user.id)

    return userInfo
  }
}

import { GenezioDeploy } from "@genezio/types";
import pg from 'pg'
const { Pool } = pg

@GenezioDeploy()
export class PostgresService {
  pool = new Pool({
    connectionString: process.env.NEON_POSTGRES_URL,
    ssl: true,
  });

  async insertUser(name: string): Promise<string> {
    await this.pool.query(
      "CREATE TABLE IF NOT EXISTS users (id serial PRIMARY KEY,name VARCHAR(255))"
    );

    await this.pool.query("INSERT INTO users (name) VALUES ($1)", [name]);
    const result = await this.pool.query("select * from users");

    return JSON.stringify(result.rows);
  }
}

import { GenezioDeploy } from '@genezio/types';
import { Redis } from '@upstash/redis'

@GenezioDeploy()
export class RedisService{
  client = new Redis({
    url: process.env.UPSTASH_REDIS_URL,
    token: process.env.UPSTASH_REDIS_TOKEN,
  })

  async insertUser(name: string): Promise<string> {
    await this.client.set('user', name);
    const result = await this.client.get('user');
    return JSON.stringify(result);
  }
}

import { GenezioDeploy, GenezioMethod,
  GenezioHttpRequest, GenezioHttpResponse } from "@genezio/types";
import axios from 'axios';

@GenezioDeploy()
export class QstashService{

  async chatbot(): Promise<boolean> {
    const url = `https://qstash.upstash.io/v2/publish/${process.env.QUEUE_WEBHOOK_URL}`;
    const payload = {
      "message": "I am your trusty chatbot! I'll help you process your tasks.",
    };

    const headers = {
      Authorization: `Bearer ${process.env.QSTASH_TOKEN}`,
      'Content-Type': 'application/json',
    };

    await axios.post(url, payload, { headers: headers })

    return true
  }

  @GenezioMethod({ type: 'http' })
  async sendReplyToChatApp(request: GenezioHttpRequest): Promise<GenezioHttpResponse> {
    const message: string = request.body.message;

    await this.#sendReplyToChatApp(message);

    const response: GenezioHttpResponse = {
      body: {"status":"ok"},
      headers: { 'content-type': 'application/json' },
      statusCode: '200',
    };
    return response;
  }
}

import { GenezioDeploy } from '@genezio/types';

@GenezioDeploy()
export class OrderService {

  // this method will run every day at midnight
  @GenezioMethod({ type: "cron", cronString: '0 0 * * *' })
  async checkForUnfinishedOrders() {
    const unfinishedOrders = await this.orders.find({
      where: {
        status: 'unfinished'
      }
    });

    await this.sendReminderEmails(orders);
  }
}