@server/next 0.26.0 → 0.27.0

package/src/helpers/types.js

@@ -1,81 +0,0 @@
-// From https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Common_types
-export default {
-  aac: "audio/aac",
-  abw: "application/x-abiword",
-  arc: "application/x-freearc",
-  avif: "image/avif",
-  avi: "video/x-msvideo",
-  azw: "application/vnd.amazon.ebook",
-  bin: "application/octet-stream",
-  bmp: "image/bmp",
-  bz: "application/x-bzip",
-  bz2: "application/x-bzip2",
-  cda: "application/x-cdf",
-  csh: "application/x-csh",
-  css: "text/css",
-  csv: "text/csv",
-  doc: "application/msword",
-  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-  eot: "application/vnd.ms-fontobject",
-  epub: "application/epub+zip",
-  gz: "application/gzip",
-  gif: "image/gif",
-  htm: "text/html",
-  html: "text/html",
-  ico: "image/vnd.microsoft.icon",
-  ics: "text/calendar",
-  jar: "application/java-archive",
-  jpeg: "image/jpeg",
-  jpg: "image/jpeg",
-  js: "text/javascript",
-  json: "application/json",
-  jsonld: "application/ld+json",
-  md: "text/markdown",
-  mid: "audio/midi",
-  midi: "audio/midi",
-  mjs: "text/javascript",
-  mp3: "audio/mpeg",
-  mp4: "video/mp4",
-  mpeg: "video/mpeg",
-  mpkg: "application/vnd.apple.installer+xml",
-  odp: "application/vnd.oasis.opendocument.presentation",
-  ods: "application/vnd.oasis.opendocument.spreadsheet",
-  odt: "application/vnd.oasis.opendocument.text",
-  oga: "audio/ogg",
-  ogv: "video/ogg",
-  ogx: "application/ogg",
-  opus: "audio/opus",
-  otf: "font/otf",
-  png: "image/png",
-  pdf: "application/pdf",
-  php: "application/x-httpd-php",
-  ppt: "application/vnd.ms-powerpoint",
-  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-  rar: "application/vnd.rar",
-  rtf: "application/rtf",
-  sh: "application/x-sh",
-  svg: "image/svg+xml",
-  tar: "application/x-tar",
-  text: "text/plain",
-  tif: "image/tiff",
-  tiff: "image/tiff",
-  ts: "video/mp2t",
-  ttf: "font/ttf",
-  txt: "text/plain",
-  vsd: "application/vnd.visio",
-  wav: "audio/wav",
-  weba: "audio/webm",
-  webm: "video/webm",
-  webp: "image/webp",
-  woff: "font/woff",
-  woff2: "font/woff2",
-  xhtml: "application/xhtml+xml",
-  xls: "application/vnd.ms-excel",
-  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-  xml: "application/xml",
-  xul: "application/vnd.mozilla.xul+xml",
-  zip: "application/zip",
-  "3gp": "video/3gpp",
-  "3g2": "video/3gpp2",
-  "7z": "application/x-7z-compressed",
-};

package/src/helpers/validate.js

@@ -1,34 +0,0 @@
-import StatusError from "./StatusError.js";
-
-export default function validate(ctx, schema) {
-  if (!schema || typeof schema !== "object") return;
-
-  let base;
-  try {
-    if (typeof schema?.body === "function") {
-      base = "body";
-      schema.body(ctx.body || {});
-    }
-    if (typeof schema?.body?.parse === "function") {
-      base = "body";
-      schema.body.parse(ctx.body || {});
-    }
-    if (typeof schema?.query === "function") {
-      base = "query";
-      schema.query(ctx.url.query || {});
-    }
-    if (typeof schema?.query?.parse === "function") {
-      base = "query";
-      schema.query.parse(ctx.url.query || {});
-    }
-  } catch (error) {
-    if (error.name === "ZodError" || error.constructor.name === "ZodError") {
-      const message = error.issues
-        .map(({ path, message }) => `[${base}.${path.join(".")}]: ${message}`)
-        .sort()
-        .join("\n");
-      throw new StatusError(message, 422);
-    }
-    throw error;
-  }
-}

package/src/index.d.ts

@@ -1,198 +0,0 @@
-type Method =
-  | "socket"
-  | "get"
-  | "head"
-  | "post"
-  | "put"
-  | "patch"
-  | "delete"
-  | "options";
-
-type Store = {
-  get: (key: string) => Promise<any>;
-  set: (
-    key: string,
-    value: any,
-    { expires }?: { expires?: string | number },
-  ) => Promise<any>;
-};
-
-type Bucket =
-  | string
-  | {
-      read: (key: string) => ReadableStream;
-      write: (
-        key: string,
-        data:
-          | string
-          | NodeJS.ArrayBufferView
-          | Iterable<string | NodeJS.ArrayBufferView>
-          | AsyncIterable<string | NodeJS.ArrayBufferView>,
-        type: BufferEncoding,
-      ) => Promise<Boolean>;
-      delete: (key: string) => Promise<Boolean>;
-    };
-
-type Auth = {
-  type: "cookie" | "token";
-  provider: "github" | "email";
-};
-type AuthString = `${Auth["type"]}:${Auth["provider"]}`;
-
-type Domain = `https://${string}/`;
-type Origin = boolean | "*" | Domain | Domain[];
-type Cors = {
-  origin: Origin;
-  methods: string;
-  headers: string;
-  credentials?: boolean;
-};
-
-type ServerOptions = {
-  port?: number;
-  views?: string | Bucket;
-  public?: string | Bucket;
-  uploads?: string | Bucket;
-  cors?: boolean | Origin | Cors;
-  auth?: AuthString | Auth;
-  store?: Store;
-};
-
-type ExtractPathParams<Path extends string> =
-  Path extends `${string}:${infer Param}(${infer Type})?/${infer Rest}`
-    ? `${Param}:${Type}?` | ExtractPathParams<`/${Rest}`>
-    : Path extends `${string}:${infer Param}(${infer Type})?`
-      ? `${Param}:${Type}?`
-      : Path extends `${string}:${infer Param}(${infer Type})/${infer Rest}`
-        ? `${Param}:${Type}` | ExtractPathParams<`/${Rest}`>
-        : Path extends `${string}:${infer Param}(${infer Type})`
-          ? `${Param}:${Type}`
-          : Path extends `${string}:${infer Param}?/${infer Rest}`
-            ? `${Param}?` | ExtractPathParams<`/${Rest}`>
-            : Path extends `${string}:${infer Param}?`
-              ? `${Param}?`
-              : Path extends `${string}:${infer Param}/${infer Rest}`
-                ? Param | ExtractPathParams<`/${Rest}`>
-                : Path extends `${string}:${infer Param}`
-                  ? Param
-                  : never;
-
-type ParamTypeMap = {
-  string: string;
-  number: number;
-  date: Date;
-};
-
-type InferParamType<T extends string> = T extends keyof ParamTypeMap
-  ? ParamTypeMap[T]
-  : string;
-
-type ParamsToObject<Params extends string> = {
-  [K in Params as K extends `${infer Key}:${infer Type}?`
-    ? Key
-    : K extends `${infer Key}:${infer Type}`
-      ? Key
-      : K extends `${infer Key}?`
-        ? Key
-        : K]: K extends `${infer Key}:${infer Type}?`
-    ? InferParamType<Type> | undefined
-    : K extends `${infer Key}:${infer Type}`
-      ? InferParamType<Type>
-      : K extends `${infer Key}?`
-        ? string | undefined
-        : string;
-};
-
-type PathToParams<Path extends string> = ParamsToObject<
-  ExtractPathParams<Path>
->;
-
-type Simplify<T> = T extends object ? { [K in keyof T]: T[K] } : T;
-
-type Context<Path extends string = string> = {
-  method: Method;
-  headers: { [key: string]: string | string[] };
-  cookies: { [key: string]: any };
-  body?: any;
-  url: URL & {
-    params: Simplify<PathToParams<Path>>; // Simplify here
-    query: { [key: string]: string };
-  };
-  options: ServerOptions;
-};
-
-type Body = string;
-
-type ContentType = "application/json" | "text/plain" | (string & {});
-
-// (src: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers)
-type Headers = {
-  "cache-control"?: string;
-  "content-type"?: ContentType;
-  "set-cookie"?: string;
-  "content-length"?: string;
-  server?: string;
-  location?: string;
-
-  [key: string]: string | undefined;
-};
-
-type InlineReply =
-  | Response
-  | { body: Body; headers?: Headers }
-  | string
-  | number
-  | undefined;
-
-type Middleware<Path extends string = string> = (
-  ctx: Context<Path>,
-) => InlineReply | void;
-
-declare interface Router {
-  get<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  head<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  post<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  put<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  patch<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  del<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  options<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-}
-
-declare interface Server {
-  /**
-   * Launch the server with the optional configuration:
-   *
-   * ```js
-   * export default server({
-   *   port: 3000,
-   *   public: './public',
-   *   store: kv(new Map()),
-   * })
-   * ```
-   *
-   * **[→ Getting Started](https://react-test.dev/documentation#attr)**
-   *
-   * **[→ Options Docs](https://react-test.dev/documentation#attr)**
-   */
-  (options?: ServerOptions): this;
-
-  socket(path: string, ...middle: Middleware[]): this;
-
-  get<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  head<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  post<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  put<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  patch<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  del<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-  options<Path extends string>(path: Path, ...middle: Middleware<Path>[]): this;
-
-  use(...middle: Middleware[]): this;
-  router(router: Router): this;
-}
-
-type headers = (obj?: Headers) => any;
-
-declare const server: Server;
-export const router: Router;
-export const headers: headers;
-export default server;

package/src/index.js

@@ -1,250 +0,0 @@
-import "./polyfill.js";
-import "./errors/index.js";
-
-import createNodeContext from "./context/node.js";
-import createWinterContext from "./context/winter.js";
-import {
-  config,
-  createWebsocket,
-  getMachine,
-  handleRequest,
-  iterate,
-  parseHeaders,
-} from "./helpers/index.js";
-
-import { assets, auth, timer, openapi } from "./middle/index.js";
-
-// Export the reply helpers
-export * from "./reply.js";
-
-export { default as ServerError } from "./ServerError.js";
-
-// Allow to create a sub-router
-export { default as router } from "./router.js";
-
-export default function server(options = {}) {
-  // Make it so that the exported one is a prototype of function()
-  if (!(this instanceof server)) {
-    return new server(options).self();
-  }
-
-  // Keep a copy of the options in the instance
-  this.opts = config(options);
-  this.platform = getMachine();
-
-  // Skip "forbidden methods" https://fetch.spec.whatwg.org/#concept-method
-  this.handlers = {
-    socket: [],
-    get: [],
-    head: [],
-    post: [],
-    put: [],
-    patch: [],
-    delete: [],
-    options: [],
-  };
-
-  // Keep a reference of the currently connected sockets
-  this.sockets = [];
-
-  // Note: required by Bun
-  this.websocket = createWebsocket(this.sockets, this.handlers);
-
-  // Initialize it right away for Node.js
-  if (this.platform.runtime === "node") {
-    this.node();
-  }
-
-  this.use(timer);
-  this.use(assets);
-  if (this.opts.openapi) {
-    const path = this.opts.openapi.path || "/docs";
-    this.get(path, openapi);
-  }
-  if (this.opts.auth) {
-    this.use(auth({ options: this.opts, app: this }));
-  }
-}
-
-server.prototype.self = function () {
-  const cb = this.callback.bind(this);
-  const proto = Object.getPrototypeOf(this);
-  for (const key in { ...proto, ...this }) {
-    if (typeof this[key] === "function") {
-      cb[key] = this[key].bind(this);
-    } else {
-      cb[key] = this[key];
-    }
-  }
-  return cb;
-};
-
-// #region Runtimes
-// Node.js
-server.prototype.node = async function () {
-  const http = await import("node:http");
-  http
-    .createServer(async (request, response) => {
-      try {
-        const ctx = await createNodeContext(request, this);
-        const out = await handleRequest(this.handlers, ctx);
-
-        response.writeHead(out.status || 200, parseHeaders(out.headers));
-        if (out.body instanceof ReadableStream) {
-          await iterate(out.body, (chunk) => response.write(chunk));
-        } else {
-          response.write(out.body || "");
-        }
-        response.end();
-      } catch (error) {
-        response.writeHead(error.status || 500);
-        response.write(error.message || "");
-        response.end();
-      }
-    })
-    .listen(this.opts.port);
-};
-
-// Netlify
-server.prototype.callback = async function (request, context) {
-  // Consider simply renaming to "ctx.next()"
-  request.context = context;
-  try {
-    if (typeof Netlify === "undefined") {
-      throw new Error("Netlify doesn't exist");
-    }
-    const ctx = await createWinterContext(request, this);
-    return await handleRequest(this.handlers, ctx);
-  } catch (error) {
-    return new Response(error.message, { status: error.status || 500 });
-  }
-};
-
-// WinterCG, Bun, Cloudflare Workers
-server.prototype.fetch = async function (request, env) {
-  if (env?.upgrade(request)) return;
-  Object.assign(globalThis.env, env); // Extend env with the passed vars
-
-  let ctx;
-  let res;
-  let error;
-  try {
-    ctx = await createWinterContext(request, this);
-    res = await handleRequest(this.handlers, ctx);
-  } catch (err) {
-    error = err;
-    res = new Response(error.message, { status: error.status || 500 });
-  }
-  ctx?.unstableFire("finish", { ...ctx, error, res, end: performance.now() });
-  return res;
-};
-
-// #region HTTP methods
-// INTERNAL
-server.prototype.handle = function (method, path, ...middleware) {
-  // Do not try to optimize, we NEED the method to remain '*' here so that
-  // it doesn't auto-finish
-  if (method === "*") {
-    for (const m in this.handlers) {
-      this.handlers[m].push([method, path, ...middleware]);
-    }
-  } else {
-    this.handlers[method].push([method, path, ...middleware]);
-  }
-
-  return this.self();
-};
-
-server.prototype.socket = function (path, ...middleware) {
-  return this.handle("socket", path, ...middleware);
-};
-
-server.prototype.get = function (path, ...middleware) {
-  return this.handle("get", path, ...middleware);
-};
-
-server.prototype.head = function (path, ...middleware) {
-  return this.handle("head", path, ...middleware);
-};
-
-server.prototype.post = function (path, ...middleware) {
-  return this.handle("post", path, ...middleware);
-};
-
-server.prototype.put = function (path, ...middleware) {
-  return this.handle("put", path, ...middleware);
-};
-
-server.prototype.patch = function (path, ...middleware) {
-  return this.handle("patch", path, ...middleware);
-};
-
-server.prototype.del = function (path, ...middleware) {
-  return this.handle("delete", path, ...middleware);
-};
-
-server.prototype.options = function (path, ...middleware) {
-  return this.handle("options", path, ...middleware);
-};
-
-server.prototype.use = function (...middleware) {
-  if (typeof middleware[0] === "string") {
-    return this.handle("*", ...middleware);
-  }
-  return this.handle("*", "*", ...middleware);
-};
-
-// Unwind the children routers into the main router
-server.prototype.router = function (basePath, router) {
-  basePath = `/${basePath}/`.replace(/^\/+/, "/").replace(/\/+$/, "/");
-  for (const m in router.handlers) {
-    for (const [method, path, ...callbacks] of router.handlers[m]) {
-      this.handle(method, basePath + path.replace(/^\//, ""), ...callbacks);
-    }
-  }
-  return this.self();
-};
-
-// #region Testing helper
-server.prototype.test = function () {
-  let cookie = "";
-  const fetch = async (path, options = {}) => {
-    if (!options.headers) options.headers = {};
-    if (options.body && typeof options.body !== "string") {
-      options.headers["content-type"] = "application/json";
-      options.body = JSON.stringify(options.body);
-    }
-    if (cookie && !options.headers.cookie) {
-      options.headers.cookie = cookie;
-    }
-    const res = await this.fetch(
-      new Request(`http://localhost:3000${path}`, options),
-    );
-
-    const headers = parseHeaders(res.headers);
-    let body;
-    if (headers["set-cookie"]) {
-      // TODO: this should really be a smart merge of the 2
-      cookie = headers["set-cookie"];
-    }
-    if (headers["content-type"]?.includes("application/json")) {
-      body = await res.json();
-    } else {
-      body = await res.text();
-    }
-    return { status: res.status, headers, body };
-  };
-  return {
-    app: this,
-    get: (path, options) => fetch(path, { method: "get", ...options }),
-    head: (path, options) => fetch(path, { method: "head", ...options }),
-    post: (path, body, options) =>
-      fetch(path, { method: "post", body, ...options }),
-    put: (path, body, options) =>
-      fetch(path, { method: "put", body, ...options }),
-    patch: (path, body, options) =>
-      fetch(path, { method: "patch", body, ...options }),
-    delete: (path, options) => fetch(path, { method: "delete", ...options }),
-    options: (path, options) => fetch(path, { method: "options", ...options }),
-  };
-};

package/src/index.test.js

@@ -1,87 +0,0 @@
-import "./test/toSucceed.js";
-
-import server, { status } from "./index.js";
-
-describe("exports", () => {
-  it("exports as a function", () => {
-    expect(typeof server()).toBe("function");
-  });
-
-  it("nested is also a function", () => {
-    expect(typeof server().get("/", () => {})).toBe("function");
-  });
-
-  it("export has a fetch", () => {
-    expect(typeof server().fetch).toBe("function");
-    expect(typeof server().get().fetch).toBe("function");
-  });
-
-  it("export has the basic methods", () => {
-    expect(typeof server().get).toBe("function");
-    expect(typeof server().post).toBe("function");
-    expect(typeof server().use).toBe("function");
-    expect(typeof server().router).toBe("function");
-  });
-
-  it("export has the basic nested methods", () => {
-    expect(typeof server().get().get).toBe("function");
-    expect(typeof server().post().post).toBe("function");
-    expect(typeof server().use().use).toBe("function");
-    expect(typeof server().get().router).toBe("function");
-  });
-
-  it("nested is also a function", () => {
-    expect(typeof server().get("/", () => {}).fetch).toBe("function");
-  });
-});
-
-describe("return different types", () => {
-  const api = server()
-    .get("/", () => "Hello world")
-    .get("/text", () => "Hello world")
-    .get("/array", () => ["Hello world"])
-    .get("/object", () => ({ hello: "world" }))
-    .get("/status", () => 201)
-    .test();
-
-  it("can get the plain text", async () => {
-    const { body } = await api.get("/text");
-    expect(body).toBe("Hello world");
-  });
-
-  it("can get the array", async () => {
-    const { body } = await api.get("/array");
-    expect(body).toEqual(["Hello world"]);
-  });
-
-  it("can get the object", async () => {
-    const req = await api.get("/object");
-    expect(req).toSucceed({ hello: "world" });
-  });
-
-  it("can get the status", async () => {
-    const req = await api.get("/status");
-    expect(req).toSucceed();
-    expect(req.status).toBe(201);
-  });
-});
-
-describe("simple post works", () => {
-  const api = server()
-    .post("/", (ctx) => status(201).send(ctx.body))
-    .test();
-
-  it("can post new data", async () => {
-    const { body, status, headers } = await api.post("/", "New Data");
-    expect(status).toBe(201);
-    expect(body).toBe("New Data");
-    expect(headers["content-type"]).toBe("text/plain");
-  });
-
-  it("will return JSON", async () => {
-    const { body, status, headers } = await api.post("/", { hello: "world" });
-    expect(status).toBe(201);
-    expect(body).toEqual({ hello: "world" });
-    expect(headers["content-type"]).toBe("application/json");
-  });
-});

package/src/index.types.ts

@@ -1,28 +0,0 @@
-import server, { headers, router } from ".";
-
-const users = router
-  .post("/users", (ctx) => {
-    console.log(ctx.url.pathname);
-    console.log(ctx.url.query);
-    console.log(ctx.url.params); // No .id
-  })
-  .get("/users/:id?", (ctx) => {
-    console.log(ctx.url.params.id);
-  })
-  .del("/users/:id", (ctx) => {
-    console.log(ctx.url.params.id);
-  });
-
-server()
-  .get("/", (ctx) => {
-    console.log(ctx.method);
-    console.log(ctx.url);
-    console.log(ctx.headers);
-    console.log(ctx.cookies);
-    console.log(ctx.body);
-    return headers();
-  })
-  .router(users)
-  .post("/", () => {
-    return 201;
-  });

package/src/middle/assets.js

@@ -1,17 +0,0 @@
-import { type } from "../reply.js";
-
-export default async function assets(ctx) {
-  if (!ctx.options.public) return;
-  if (ctx.method !== "get") return;
-  // The homepage _cannot_ be a file by definition. We could consider sending
-  // `index.html`, but that's easy with `.get('/', () => file('index.html'))
-  if (ctx.url.pathname === "/") return;
-  try {
-    // TODO: streaming
-    const asset = await ctx.options.public.read(ctx.url.pathname, null);
-    if (!asset) return;
-    return type(ctx.url.pathname.split(".").pop()).send(asset);
-  } catch (error) {
-    // NO-OP; if there's no file, keep going the normal flow
-  }
-}