eden/treaty/parameters

[giscus[bot]]

eden/treaty/parameters

Ergonomic Framework for Humans. TypeScript framework supercharged by Bun with End - to - End Type Safety, unified type system and outstanding developer experience

https://elysiajs.com/eden/treaty/parameters.html

[khotei]

Is it planned to add type inference for query, headers?

export const restaurantsApp = new Elysia({
  prefix: "/restaurants",
})
  .use(restaurantMenuApp)
  .get(
    "/search",
    async ({ query }) => {
      return RestaurantsService.search(query)
    },
    {
      query: RestaurantsModel.schema.query,
    },
  )


export const RestaurantsModel = {
  schema: {
    query: Zod.object({
      search: restaurantSelectSchema.shape.name
        .optional()
        .nullable(),
    }),
  },
}

import { restaurantsApp } from "./restaurants-app"

const api = treaty(restaurantsApp)

const response = await api.restaurants.search.get()

Type:

get: (options?: ({
  headers?: Record<string, unknown> | undefined
  query?: Record<string, unknown> | undefined
  fetch?: RequestInit | undefined
} | undefined))

[peterlustig78]

This should already work?
Since Elysia 1.4 this does also work with zod and others. But in my test it does work. Maybe you are using old elysia and eden versions and can update.

// --------- Server (Elysia) ----------
import { Elysia, t } from 'elysia';
const a = new Elysia()
  .get(
    '/profile',
    ({ headers }) => (console.log(headers.authorization)),
    {
      // <- enforce that Authorization must be present
      headers: t.Object({
        authorization: t.String(),
      }),
    }
  )
  .listen(3000);

// --------- Client (Eden treaty) ----------
import { treaty } from '@elysiajs/eden';
type Api = typeof a;
const api = treaty<Api>('http://localhost:3000');
await api.profile.get({ // this is typesafe! it checks the route header enforced in the server above. 
  headers: {
    authorization: "Bearer Aponia"
  }
}); // sends Authorization: Bearer Aponia.

console.log("Test Done")
process.exit(0)

[ReptoxX]

Treaty Type inference doesn't work with Arktype.

// --------- Model ---------
import { type } from "arktype";
const customer = type({
  "+": "delete",
  id: "string",
  fullName: "string?",
  email: "string?"
})
const createCustomer = customer.omit("id");
export const customerModels = new Elysia().model({
  create: createCustomer,
  customer: customer,
})

// --------- Server ---------
const a = new Elysia()
  .use(customerModels)
  .prefix("model", "customer.")
  .post(
    "/customer",
    async function createCustomer({ body }) {
      console.log(body);
    },
    {
      body: "customer.Create",
      response: "customer.Customer",
    },
)
export type App = typeof a;
// --------- Client (Eden treaty) ---------
import { treaty } from '@elysiajs/eden';
const api = treaty<App>("http://localhost:3000");
await api.customer.post({
  fullName: true, // <-- The type is now any
  email: 123456789, // <-- Type is any, i can enter anything it throws on request
});

[ReptoxX]

Okay i figured out why this keeps happening. You need to have bun-types installed in the frontend even tho it might not use bun in the first place.
Is eden even compatible to nodejs? While i'm using bun in the backend, i might not be able to use it immediately in the frontend aswell.