release: sync dev → main

.agents/skills/elysiajs/examples/basic.ts

@@ -0,0 +1,7 @@
+import { Elysia, t } from "elysia";
+
+new Elysia().get("/", "Hello Elysia").post("/", ({ body: { name } }) => name, {
+  body: t.Object({
+    name: t.String(),
+  }),
+});

.agents/skills/elysiajs/examples/body-parser.ts

@@ -0,0 +1,33 @@
+import { Elysia, t } from "elysia";
+
+const app = new Elysia()
+  // Add custom body parser
+  .onParse(async ({ request, contentType }) => {
+    switch (contentType) {
+      case "application/Elysia":
+        return request.text();
+    }
+  })
+  .post("/", ({ body: { username } }) => `Hi ${username}`, {
+    body: t.Object({
+      id: t.Number(),
+      username: t.String(),
+    }),
+  })
+  // Increase id by 1 from body before main handler
+  .post("/transform", ({ body }) => body, {
+    transform: ({ body }) => {
+      body.id = body.id + 1;
+    },
+    body: t.Object({
+      id: t.Number(),
+      username: t.String(),
+    }),
+    detail: {
+      summary: "A",
+    },
+  })
+  .post("/mirror", ({ body }) => body)
+  .listen(3000);
+
+console.log("🦊 Elysia is running at :8080");

.agents/skills/elysiajs/examples/complex.ts

@@ -0,0 +1,111 @@
+import { Elysia, file, t } from "elysia";
+
+const loggerPlugin = new Elysia()
+  .get("/hi", () => "Hi")
+  .decorate("log", () => "A")
+  .decorate("date", () => new Date())
+  .state("fromPlugin", "From Logger")
+  .use((app) => app.state("abc", "abc"));
+
+const app = new Elysia()
+  .onRequest(({ set }) => {
+    set.headers = {
+      "Access-Control-Allow-Origin": "*",
+    };
+  })
+  .onError(({ code }) => {
+    if (code === "NOT_FOUND") return "Not Found :(";
+  })
+  .use(loggerPlugin)
+  .state("build", Date.now())
+  .get("/", "Elysia")
+  .get("/tako", file("./example/takodachi.png"))
+  .get("/json", () => ({
+    hi: "world",
+  }))
+  .get("/root/plugin/log", ({ log, store: { build } }) => {
+    log();
+
+    return build;
+  })
+  .get("/wildcard/*", () => "Hi Wildcard")
+  .get("/query", () => "Elysia", {
+    beforeHandle: ({ query }) => {
+      console.log("Name:", query?.name);
+
+      if (query?.name === "aom") return "Hi saltyaom";
+    },
+    query: t.Object({
+      name: t.String(),
+    }),
+  })
+  .post("/json", async ({ body }) => body, {
+    body: t.Object({
+      name: t.String(),
+      additional: t.String(),
+    }),
+  })
+  .post("/transform-body", async ({ body }) => body, {
+    beforeHandle: (ctx) => {
+      ctx.body = {
+        ...ctx.body,
+        additional: "Elysia",
+      };
+    },
+    body: t.Object({
+      name: t.String(),
+      additional: t.String(),
+    }),
+  })
+  .get("/id/:id", ({ params: { id } }) => id, {
+    transform({ params }) {
+      params.id = +params.id;
+    },
+    params: t.Object({
+      id: t.Number(),
+    }),
+  })
+  .post("/new/:id", async ({ body, params }) => body, {
+    params: t.Object({
+      id: t.Number(),
+    }),
+    body: t.Object({
+      username: t.String(),
+    }),
+  })
+  .get("/trailing-slash", () => "A")
+  .group("/group", (app) =>
+    app
+      .onBeforeHandle(({ query }) => {
+        if (query?.name === "aom") return "Hi saltyaom";
+      })
+      .get("/", () => "From Group")
+      .get("/hi", () => "HI GROUP")
+      .get("/elysia", () => "Welcome to Elysian Realm")
+      .get("/fbk", () => "FuBuKing"),
+  )
+  .get("/response-header", ({ set }) => {
+    set.status = 404;
+    set.headers["a"] = "b";
+
+    return "A";
+  })
+  .get("/this/is/my/deep/nested/root", () => "Hi")
+  .get("/build", ({ store: { build } }) => build)
+  .get("/ref", ({ date }) => date())
+  .get("/response", () => new Response("Hi"))
+  .get("/error", () => new Error("Something went wrong"))
+  .get("/401", ({ set }) => {
+    set.status = 401;
+
+    return "Status should be 401";
+  })
+  .get("/timeout", async () => {
+    await new Promise((resolve) => setTimeout(resolve, 2000));
+
+    return "A";
+  })
+  .all("/all", () => "hi")
+  .listen(8080, ({ hostname, port }) => {
+    console.log(`🦊 Elysia is running at http://${hostname}:${port}`);
+  });

.agents/skills/elysiajs/examples/cookie.ts

@@ -0,0 +1,45 @@
+import { Elysia, t } from "elysia";
+
+const app = new Elysia({
+  cookie: {
+    secrets: "Fischl von Luftschloss Narfidort",
+    sign: ["name"],
+  },
+})
+  .get(
+    "/council",
+    ({ cookie: { council } }) =>
+      (council.value = [
+        {
+          name: "Rin",
+          affilation: "Administration",
+        },
+      ]),
+    {
+      cookie: t.Cookie({
+        council: t.Array(
+          t.Object({
+            name: t.String(),
+            affilation: t.String(),
+          }),
+        ),
+      }),
+    },
+  )
+  .get("/create", ({ cookie: { name } }) => (name.value = "Himari"))
+  .get(
+    "/update",
+    ({ cookie: { name } }) => {
+      name.value = "seminar: Rio";
+      name.value = "seminar: Himari";
+      name.maxAge = 86400;
+
+      return name.value;
+    },
+    {
+      cookie: t.Cookie({
+        name: t.Optional(t.String()),
+      }),
+    },
+  )
+  .listen(3000);

.agents/skills/elysiajs/examples/error.ts

@@ -0,0 +1,38 @@
+import { Elysia, t } from "elysia";
+
+class CustomError extends Error {
+  constructor(public name: string) {
+    super(name);
+  }
+}
+
+new Elysia()
+  .error({
+    CUSTOM_ERROR: CustomError,
+  })
+  // global handler
+  .onError(({ code, error, status }) => {
+    switch (code) {
+      case "CUSTOM_ERROR":
+        return status(401, { message: error.message });
+
+      case "NOT_FOUND":
+        return "Not found :(";
+    }
+  })
+  .post("/", ({ body }) => body, {
+    body: t.Object({
+      username: t.String(),
+      password: t.String(),
+      nested: t.Optional(
+        t.Object({
+          hi: t.String(),
+        }),
+      ),
+    }),
+    // local handler
+    error({ error }) {
+      console.log(error);
+    },
+  })
+  .listen(3000);

.agents/skills/elysiajs/examples/file.ts

@@ -0,0 +1,8 @@
+import { Elysia, file } from "elysia";
+
+/**
+ * Example of handle single static file
+ *
+ * @see https://github.com/elysiajs/elysia-static
+ */
+new Elysia().get("/tako", file("./example/takodachi.png")).listen(3000);

.agents/skills/elysiajs/examples/guard.ts

@@ -0,0 +1,34 @@
+import { Elysia, t } from "elysia";
+
+new Elysia()
+  .state("name", "salt")
+  .get("/", ({ store: { name } }) => `Hi ${name}`, {
+    query: t.Object({
+      name: t.String(),
+    }),
+  })
+  // If query 'name' is not preset, skip the whole handler
+  .guard(
+    {
+      query: t.Object({
+        name: t.String(),
+      }),
+    },
+    (app) =>
+      app
+        // Query type is inherited from guard
+        .get("/profile", ({ query }) => `Hi`)
+        // Store is inherited
+        .post("/name", ({ store: { name }, body, query }) => name, {
+          body: t.Object({
+            id: t.Number({
+              minimum: 5,
+            }),
+            username: t.String(),
+            profile: t.Object({
+              name: t.String(),
+            }),
+          }),
+        }),
+  )
+  .listen(3000);

.agents/skills/elysiajs/examples/map-response.ts

@@ -0,0 +1,14 @@
+import { Elysia } from "elysia";
+
+const prettyJson = new Elysia()
+  .mapResponse(({ response }) => {
+    if (response instanceof Object) return new Response(JSON.stringify(response, null, 4));
+  })
+  .as("scoped");
+
+new Elysia()
+  .use(prettyJson)
+  .get("/", () => ({
+    hello: "world",
+  }))
+  .listen(3000);

.agents/skills/elysiajs/examples/redirect.ts

@@ -0,0 +1,6 @@
+import { Elysia } from "elysia";
+
+new Elysia()
+  .get("/", () => "Hi")
+  .get("/redirect", ({ redirect }) => redirect("/"))
+  .listen(3000);

.agents/skills/elysiajs/examples/rename.ts

@@ -0,0 +1,27 @@
+import { Elysia, t } from "elysia";
+
+// ? Elysia#83 | Proposal: Standardized way of renaming third party plugin-scoped stuff
+// this would be a plugin provided by a third party
+const myPlugin = new Elysia().decorate("myProperty", 42).model("salt", t.String());
+
+new Elysia()
+  .use(
+    myPlugin
+      // map decorator, rename "myProperty" to "renamedProperty"
+      .decorate(({ myProperty, ...decorators }) => ({
+        renamedProperty: myProperty,
+        ...decorators,
+      }))
+      // map model, rename "salt" to "pepper"
+      .model(({ salt, ...models }) => ({
+        ...models,
+        pepper: t.String(),
+      }))
+      // Add prefix
+      .prefix("decorator", "unstable"),
+  )
+  .get("/mapped", ({ unstableRenamedProperty }) => unstableRenamedProperty)
+  .post("/pepper", ({ body }) => body, {
+    body: "pepper",
+    // response: t.String()
+  });

.agents/skills/elysiajs/examples/schema.ts

@@ -0,0 +1,61 @@
+import { Elysia, t } from "elysia";
+
+const app = new Elysia()
+  .model({
+    name: t.Object({
+      name: t.String(),
+    }),
+    b: t.Object({
+      response: t.Number(),
+    }),
+    authorization: t.Object({
+      authorization: t.String(),
+    }),
+  })
+  // Strictly validate response
+  .get("/", () => "hi")
+  // Strictly validate body and response
+  .post("/", ({ body, query }) => body.id, {
+    body: t.Object({
+      id: t.Number(),
+      username: t.String(),
+      profile: t.Object({
+        name: t.String(),
+      }),
+    }),
+  })
+  // Strictly validate query, params, and body
+  .get("/query/:id", ({ query: { name }, params }) => name, {
+    query: t.Object({
+      name: t.String(),
+    }),
+    params: t.Object({
+      id: t.String(),
+    }),
+    response: {
+      200: t.String(),
+      300: t.Object({
+        error: t.String(),
+      }),
+    },
+  })
+  .guard(
+    {
+      headers: "authorization",
+    },
+    (app) =>
+      app
+        .derive(({ headers }) => ({
+          userId: headers.authorization,
+        }))
+        .get("/", ({ userId }) => "A")
+        .post("/id/:id", ({ query, body, params, userId }) => body, {
+          params: t.Object({
+            id: t.Number(),
+          }),
+          transform({ params }) {
+            params.id = +params.id;
+          },
+        }),
+  )
+  .listen(3000);