Export typebox Parse or something of the sort

[vladkrasn]

What is the problem this feature would solve?

On startup of the app, I want to validate variables pulled from .env and export them as one env object.

Something like what they're doing with Zod here.

On startup, I want application to throw an error if something's missing, and I want to reuse those parsed variables not only inside of Elysia instance, but also in other parts of the application (for example, for db connection).

What is the feature you are proposing to solve the problem?

Since Elysia already contains Typebox inside of itself, it would be really nice if we could use their Value.Parse method without needing to install additional packages.

What alternatives have you considered?

The alternative is to add another validation package to the project, or Typebox itself. But Elysia already has Typebox inside!

[SalvadorLekan]

What I did in my case since Elysia is dependent on @sinclair/typebox, It's already installed.

import { Value } from "@sinclair/typebox/value";
import { t } from "elysia";

const envSchema = t.Object({
});

const env = Value.Parse(envSchema, process.env);

export default env;

[vladkrasn]

What I did in my case since Elysia is dependent on @sinclair/typebox, It's already installed.

import { Value } from "@sinclair/typebox/value";
import { t } from "elysia";

const envSchema = t.Object({
});

const env = Value.Parse(envSchema, process.env);

export default env;

Oh, I didn't know that you can do that.

Though I guess it's kinda hacky, since it doesn't get picked up by Typescript's import suggestions, and only works with package managers that keep all installed packages in root of node_modules.

[vitorTheDev]

+1 since I also need Value.Parse

[PatrickHoeckler]

What I did in my case since Elysia is dependent on @sinclair/typebox, It's already installed.

import { Value } from "@sinclair/typebox/value";
import { t } from "elysia";

const envSchema = t.Object({
});

const env = Value.Parse(envSchema, process.env);

export default env;

I've had some weird problem with typescript complaining about the type of envSchema not being valid as the first parameter to the Value.parse function.

Argument of type 'TObject<{ name: TString; }>' is not assignable to parameter of type 'TSchema'.
  Property '[Kind]' is missing in type 'TObject<{ name: TString; }>' but required in type 'TSchema'.ts(2345)

Maybe it's something about my setup, but looking further I found that when importing t from elysia it would infer the types from the d.ts files in @sinclair/typebox/build/cjs. However, when importing stuff directly from @sinclair/typebox it would infer from the files in @sinclair/typebox/build/ejs.

Both directories are defining the following symbol:

export declare const Kind: unique symbol;

Since the symbol is unique, each import was using a different value for the Kind symbol, resulting in the type error.

So, I couldn't use a type defined with t from elysia in a function like Value.parse imported from typebox . I fixed it by creating a custom function to parse the value, while internally casting to fix the type issues:

import { Kind } from "@sinclair/typebox";
import { Value } from "@sinclair/typebox/value";
import { t, type TSchema } from "elysia";

function parseValue<T extends TSchema>(schema: T, value: unknown) {
  return Value.Parse(schema as unknown as T & { [Kind]: "" }, value);
}

const envSchema = t.Object({
});

const env = parseValue(envSchema, process.env);

export default env;

[vladkrasn]

You can just use Type from typebox in this case, but it's still a crutch

[PatrickHoeckler]

You can just use Type from typebox in this case, but it's still a crutch

You're right, but then I can't use the same type to parse the body in my endpoints. For example:

import { Type } from "@sinclair/typebox";
import { Value } from "@sinclair/typebox/value";
import { Elysia, t } from "elysia";

const customType = Type.RegExp(/example/);

Value.Parse(
  Type.Object({
    value: customType, // this works, because here is using types from typebox
  }),
  {}
);

const app = new Elysia().get(
  "/",
  ({ body }) => {
    return body;
  },
  {
    body: t.Object({
      value: customType, // this errors, because here is using types from elysia
    }),

    // this also errors
    // body: Type.Object({
    //   value: customType,
    // }),
  }
);

It seems I can't mix types created from Type and from elysia t. 😢

[terion-name]

What I did in my case since Elysia is dependent on @sinclair/typebox, It's already installed.
import { Value } from "@sinclair/typebox/value";
import { t } from "elysia";
const envSchema = t.Object({
});
const env = Value.Parse(envSchema, process.env);
export default env;

I've had some weird problem with typescript complaining about the type of envSchema not being valid as the first parameter to the Value.parse function.

Argument of type 'TObject<{ name: TString; }>' is not assignable to parameter of type 'TSchema'.
  Property '[Kind]' is missing in type 'TObject<{ name: TString; }>' but required in type 'TSchema'.ts(2345)

Maybe it's something about my setup, but looking further I found that when importing t from elysia it would infer the types from the d.ts files in @sinclair/typebox/build/cjs. However, when importing stuff directly from @sinclair/typebox it would infer from the files in @sinclair/typebox/build/ejs.

Both directories are defining the following symbol:

export declare const Kind: unique symbol;
Since the symbol is unique, each import was using a different value for the Kind symbol, resulting in the type error.

So, I couldn't use a type defined with t from elysia in a function like Value.parse imported from typebox . I fixed it by creating a custom function to parse the value, while internally casting to fix the type issues:

import { Kind } from "@sinclair/typebox";
import { Value } from "@sinclair/typebox/value";
import { t, type TSchema } from "elysia";

function parseValue(schema: T, value: unknown) {
return Value.Parse(schema as unknown as T & { [Kind]: "" }, value);
}

const envSchema = t.Object({
});

const env = parseValue(envSchema, process.env);

export default env;

This fails with elysia's custom types like File, so definetly we need exported customized parsers, validators and all this stuff

[tve]

I need this too!
I need to convert an object structure after it passes simple validation to a different type and that fails.
A simple example of the failure (using Bun) is:

> import { Value } from '@sinclair/typebox/value'
undefined
> import { Type } from '@sinclair/typebox/type'
undefined
> import { t } from 'elysia'
undefined
> typeof Value.Convert(t.Integer(), "123")
'string'  // <=== Oooops!
> typeof Value.Convert(Type.Integer(), "123")
'number'

oddly, this works:

> typeof Value.Convert(t.Number(), "123")
'number'

This whole 't' thing is a minefield!

[hyoretsu]

Bump