@server/next 0.27.1 → 0.27.4

package/index.d.ts

@@ -0,0 +1,392 @@
+type Method = "get" | "post" | "put" | "patch" | "delete" | "head" | "options" | "socket";
+type ServerConfig = {
+    User?: Record<string, string | number | boolean | Date | null | undefined>;
+};
+type RouteOptions = {
+    tags?: string | string[];
+    title?: string;
+    description?: string;
+};
+type Cookie = {
+    value?: string;
+    path?: string;
+    expires?: number | string | Date;
+};
+type RouterMethod = "*" | Method;
+type Bucket = {
+    read: (path: string) => Promise<ReadableStream | null>;
+    write: (path: string, data: string | Buffer) => Promise<void | string>;
+    delete: (path: string) => Promise<boolean>;
+};
+type CorsSettings = {
+    origin: string | boolean;
+    methods: string;
+    headers: string;
+};
+type CorsOptions = boolean | string | string[] | {
+    origin?: string | string[];
+    methods?: string | Method[];
+    headers?: string | string[];
+};
+type BasicValue = string | number | boolean | null;
+type SerializableValue = BasicValue | {
+    [key: string]: SerializableValue;
+} | Array<SerializableValue>;
+type KVStore = {
+    name?: string;
+    prefix: (key: string) => KVStore;
+    get: <T = SerializableValue>(key: string) => Promise<T>;
+    set: <T = SerializableValue>(key: string, value: T, options?: {
+        expires: string | number;
+    }) => Promise<void | string>;
+    has: (key: string) => Promise<boolean>;
+    del: (key: string) => Promise<void | string>;
+    keys: () => Promise<string[]>;
+};
+type Provider = "email" | "github";
+type Strategy = "cookie" | "jwt" | "token";
+type AuthSession = {
+    id: string;
+    provider: Provider;
+    strategy: Strategy;
+    user: string;
+};
+type AuthUser<T = object> = T & {
+    id: string | number;
+    provider: Provider;
+    strategy: Strategy;
+    email: string;
+};
+type ProviderString = Provider | `${Provider}|${Provider}`;
+type AuthOption = `${Strategy}:${Provider | ProviderString}` | {
+    provider: Provider | ProviderString | Provider[];
+    strategy: Strategy;
+    session?: KVStore;
+    store?: KVStore;
+    redirect?: string;
+    cleanUser?: <T = AuthUser>(user: T) => T | Promise<T>;
+};
+type AuthSettings = {
+    provider: Provider[];
+    strategy: Strategy;
+    store: KVStore;
+    session: KVStore;
+    cleanUser: <T = AuthUser>(user: T) => T | Promise<T>;
+    redirect: string;
+};
+type Options = {
+    port?: number;
+    secret?: string;
+    views?: string | Bucket;
+    public?: string | Bucket;
+    uploads?: string | Bucket;
+    store?: KVStore;
+    cookies?: KVStore;
+    session?: KVStore | {
+        store: KVStore;
+    };
+    cors?: CorsOptions;
+    auth?: AuthOption;
+    openapi?: any;
+};
+type Settings = {
+    port: number;
+    secret: string;
+    views?: Bucket;
+    public?: Bucket;
+    uploads?: Bucket;
+    store?: KVStore;
+    cookies?: KVStore;
+    session?: {
+        store: KVStore;
+    };
+    cors?: CorsSettings;
+    auth?: AuthSettings;
+    openapi?: any;
+};
+type Time = {
+    (name: string): void;
+    times: [string, number][];
+    headers: () => string;
+};
+type Platform = {
+    provider: string | null;
+    runtime: string | null;
+    production: boolean;
+};
+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 BunEnv = Record<string, string> & {
+    upgrade?: (req: Request) => boolean;
+};
+type EventCallback = (data: Context & SerializableValue) => void;
+type Events = Record<string, EventCallback[]> & {
+    on?: (key: string, cb: (value?: Context & SerializableValue) => void) => void;
+    trigger?: (key: string, value?: Partial<Context & SerializableValue>) => void;
+};
+type Context<Params extends Record<string, string> = Record<string, string>, O extends ServerConfig = object> = {
+    method: Method;
+    headers: Record<string, string | string[]>;
+    cookies: Record<string, string>;
+    body?: SerializableValue;
+    url: URL & {
+        params: Params;
+        query: Record<string, string>;
+    };
+    options: Settings;
+    platform: Platform;
+    time?: Time;
+    socket?: WebSocket;
+    sockets?: WebSocket[];
+    session?: Record<string, BasicValue>;
+    user?: O extends {
+        User: infer U;
+    } ? U & AuthUser : AuthUser;
+    init: number;
+    events: Events;
+    req?: Request;
+    res?: Response & {
+        cookies?: Record<string, string>;
+    };
+    app: Server;
+};
+type InlineReply = Response | {
+    body: string;
+    headers?: Headers;
+} | SerializableValue;
+type Body = InlineReply;
+type Middleware<O extends ServerConfig = object, Params extends Record<string, string> = Record<string, string>> = (ctx: Context<Params, O>) => InlineReply | Promise<InlineReply> | void | Promise<void>;
+
+type Variables = Record<string, string | string[]>;
+type ExtendError = string | {
+    message: string;
+    status: number;
+};
+interface ServerErrorConstructor {
+    extend(errors: Record<string, ExtendError>): Record<string, ExtendError>;
+    [key: string]: ((vars?: Variables) => ServerError) | any;
+}
+declare class ServerError extends Error {
+    code: string;
+    status: number;
+    constructor(code: string, status: number, message: string | ((vars: Variables) => string), vars?: Variables);
+    static extend(errors: Record<string, ExtendError>): Record<string, ExtendError>;
+}
+declare const TypedServerError: typeof ServerError & ServerErrorConstructor;
+
+declare global {
+    var env: Record<string, any>;
+}
+
+type Mids<O, Path extends string> = Middleware<O, PathToParams<Path>>[];
+type PathOrMiddle<O extends ServerConfig = object> = string | Middleware<O>;
+type FullRoute = [RouterMethod, string, ...Middleware[]][];
+declare class Router<O extends ServerConfig = object> {
+    handlers: Record<Method, FullRoute>;
+    self(): this;
+    handle(method: RouterMethod, path: PathOrMiddle<O>, ...middleware: Middleware<O>[]): this;
+    socket<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    socket<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    socket(...middleware: Middleware<O>[]): this;
+    socket(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    get<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    get<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    get(...middleware: Middleware<O>[]): this;
+    get(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    head<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    head<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    head(...middleware: Middleware<O>[]): this;
+    head(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    post<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    post<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    post(...middleware: Middleware<O>[]): this;
+    post(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    put<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    put<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    put(...middleware: Middleware<O>[]): this;
+    put(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    patch<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    patch<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    patch(...middleware: Middleware<O>[]): this;
+    patch(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    del<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    del<Path extends string>(path: Path, options: RouteOptions, ...middleware: Mids<O, Path>): this;
+    del(...middleware: Middleware<O>[]): this;
+    del(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    options<Path extends string>(path: Path, ...middleware: Mids<O, Path>): this;
+    options<Path extends string>(path: Path, options: RouteOptions, ...mid: Mids<O, Path>): this;
+    options(...middleware: Middleware<O>[]): this;
+    options(options: RouteOptions, ...middleware: Middleware<O>[]): this;
+    use(...middleware: Middleware[]): this;
+    use(path: string, ...middleware: Middleware[]): this;
+    use(router: Router): this;
+    use(path: string, router: Router): this;
+}
+declare function router(): Router;
+
+type CookieOptions = string | string[] | Cookie | Cookie[] | null;
+interface ResponseData {
+    headers: Headers;
+    status?: number;
+}
+declare class Reply {
+    res: ResponseData;
+    constructor();
+    status(status: number): this;
+    type(type?: string): this;
+    download(name?: string): this;
+    headers(key: string | Record<string, string>, value?: string): this;
+    cookies(key: string | Record<string, CookieOptions>, value?: CookieOptions): this;
+    json(body: unknown): Response;
+    redirect(path: string): Response;
+    file(path: string): Promise<Response>;
+    send(body?: string | Buffer | ReadableStream | any): Response;
+}
+type Params<K extends keyof Reply> = Reply[K] extends (...args: infer A) => any ? A : never;
+declare const status: (...args: Params<"status">) => Reply;
+declare const headers: (...args: Params<"headers">) => Reply;
+declare const type: (...args: Params<"type">) => Reply;
+declare const download: (...args: Params<"download">) => Reply;
+declare const cookies: (...args: Params<"cookies">) => Reply;
+declare const send: (...args: Params<"send">) => Response;
+declare const json: (...args: Params<"json">) => Response;
+declare const file: (...args: Params<"file">) => Promise<Response>;
+declare const redirect: (...args: Params<"redirect">) => Response;
+
+declare class Server<O extends ServerConfig = object> extends Router<O> {
+    settings: Settings;
+    platform: Platform;
+    sockets: any[];
+    websocket: any;
+    port?: number;
+    constructor(options?: Options);
+    self(): this & ((request: any, context?: any) => any);
+    node(): Promise<void>;
+    fetch(request: Request, env?: BunEnv): Promise<Response>;
+    callback(request: Request, context: unknown): Promise<Response>;
+    test(): {
+        get: (path: string, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+        head: (path: string, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+        post: (path: string, body?: string | number | boolean | ArrayBuffer | {
+            [key: string]: SerializableValue;
+        } | SerializableValue[] | ReadableStream<any> | Blob | ArrayBufferView<ArrayBuffer> | FormData | URLSearchParams, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+        put: (path: string, body?: string | number | boolean | ArrayBuffer | {
+            [key: string]: SerializableValue;
+        } | SerializableValue[] | ReadableStream<any> | Blob | ArrayBufferView<ArrayBuffer> | FormData | URLSearchParams, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+        patch: (path: string, body?: string | number | boolean | ArrayBuffer | {
+            [key: string]: SerializableValue;
+        } | SerializableValue[] | ReadableStream<any> | Blob | ArrayBufferView<ArrayBuffer> | FormData | URLSearchParams, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+        delete: (path: string, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+        options: (path: string, options?: {
+            cache?: RequestCache;
+            credentials?: RequestCredentials;
+            headers?: HeadersInit;
+            integrity?: string;
+            keepalive?: boolean;
+            method?: string;
+            mode?: RequestMode;
+            priority?: RequestPriority;
+            redirect?: RequestRedirect;
+            referrer?: string;
+            referrerPolicy?: ReferrerPolicy;
+            signal?: AbortSignal | null;
+            window?: null;
+        }) => Promise<Response>;
+    };
+}
+declare function server<Options>(options?: {}): Server<Options> & ((request: any, context?: any) => any);
+
+export { type AuthOption, type AuthSession, type AuthSettings, type AuthUser, type BasicValue, type Body, type Bucket, type BunEnv, type Context, type Cookie, type CorsSettings, type EventCallback, type ExtractPathParams, type InferParamType, type InlineReply, type KVStore, type Method, type Middleware, type Options, type ParamTypeMap, type ParamsToObject, type PathToParams, type Platform, type Provider, type RouteOptions, type RouterMethod, type SerializableValue, Server, type ServerConfig, TypedServerError as ServerError, type Settings, type Strategy, type Time, cookies, server as default, download, file, headers, json, redirect, router, send, status, type };

package/index.js

@@ -172,21 +172,14 @@ var email_default = {
 };
 
 // src/reply.ts
+var EXPIRED = (/* @__PURE__ */ new Date(0)).toUTCString();
 var Reply = class {
   res;
   constructor() {
     this.res = {
-      headers: {},
-      cookies: {}
+      headers: new Headers()
     };
   }
-  generateHeaders() {
-    const headers2 = new Headers(this.res.headers);
-    for (const cookie of createCookies(this.res.cookies)) {
-      headers2.append("set-cookie", cookie);
-    }
-    return headers2;
-  }
   status(status2) {
     this.res.status = status2;
     return this;
@@ -194,46 +187,55 @@ var Reply = class {
   type(type2) {
     if (!type2) return this;
     type2 = types_default[type2.replace(/^\./, "")] || type2;
-    return this.headers({ "content-type": type2 });
+    this.res.headers.set("content-type", type2);
+    return this;
   }
-  download(name, type2) {
-    if (name && !type2) type2 = name.split(".").pop();
-    if (type2) this.type(type2);
-    const filename = name ? `; filename="${name}"` : "";
-    return this.headers({ "content-disposition": `attachment${filename}` });
+  download(name) {
+    const ext = name?.split(".").pop();
+    if (type && ext && !this.res.headers.get("content-type")) this.type(ext);
+    const filename = name ? `; filename="${encodeURIComponent(name)}"` : "";
+    return this.headers("content-disposition", `attachment${filename}`);
   }
-  headers(headers2) {
-    if (!headers2 || typeof headers2 !== "object") return this;
-    for (const key in headers2) {
-      this.res.headers[key] = headers2[key];
+  headers(key, value) {
+    if (typeof key !== "string") {
+      Object.entries(key).map(([key2, value2]) => this.headers(key2, value2));
+      return this;
     }
+    if (Array.isArray(value)) {
+      Object.values(value).map((val) => this.headers(key, val));
+      return this;
+    }
+    this.res.headers.append(key, value);
     return this;
   }
-  cookies(cookies2) {
-    if (!cookies2 || typeof cookies2 !== "object") return this;
-    for (const key in cookies2) {
-      if (typeof cookies2[key] === "string") {
-        this.res.cookies[key] = { value: cookies2[key] };
-      } else {
-        this.res.cookies[key] = cookies2[key];
-      }
+  cookies(key, value) {
+    if (typeof key === "object") {
+      Object.entries(key).map(([key2, value2]) => this.cookies(key2, value2));
+      return this;
     }
-    return this;
+    if (Array.isArray(value)) {
+      Object.values(value).map((val) => this.cookies(key, val));
+      return this;
+    }
+    console.log(key, value);
+    if (value === null) return this.cookies(key, { expires: EXPIRED });
+    if (typeof value !== "object") return this.cookies(key, { value });
+    return this.headers("set-cookie", createCookies(key, value));
   }
   json(body) {
-    return this.headers({
-      "content-type": "application/json"
-    }).send(JSON.stringify(body));
+    return this.headers("content-type", "application/json").send(
+      JSON.stringify(body)
+    );
   }
-  redirect(Location) {
-    return this.headers({ Location }).status(302).send();
+  redirect(path2) {
+    return this.headers("location", path2).status(302).send();
   }
-  async file(path2, renderer = async (data) => data) {
+  async file(path2) {
     try {
-      const fs2 = await import("fs/promises");
-      const data = await fs2.readFile(path2);
+      const fs2 = await import("fs");
       const ext = path2.split(".").pop();
-      return this.type(ext).send(await renderer(data));
+      const stream = fs2.createReadStream(path2);
+      return this.type(ext).send(stream);
     } catch (error) {
       if (error.code === "ENOENT") {
         return this.status(404).send();
@@ -241,50 +243,39 @@ var Reply = class {
       throw error;
     }
   }
-  async view(path2, renderer = async (data) => data, ctx) {
-    if (!ctx?.options.views) {
-      throw new Error("Views not enabled");
-    }
-    const data = await ctx.options.views.read(path2);
-    if (!data) return this.status(404).send();
-    return this.type(path2.split(".").pop()).send(await renderer(data));
-  }
   send(body = "") {
-    const { status: status2 = 200 } = this.res;
+    const { status: status2 = 200, headers: headers2 } = this.res;
     if (typeof body === "string") {
-      if (!this.res.headers["content-type"]) {
-        const isHtml = body.startsWith("<");
-        this.res.headers["content-type"] = isHtml ? "text/html" : "text/plain";
+      if (!headers2.get("content-type")) {
+        const isHtml = body.trim().startsWith("<");
+        headers2.set("content-type", isHtml ? "text/html" : "text/plain");
       }
-      const headers2 = this.generateHeaders();
       return new Response(body, { status: status2, headers: headers2 });
     }
     const name = body?.constructor?.name;
     if (name === "Buffer") {
-      const headers2 = this.generateHeaders();
       return new Response(body, { status: status2, headers: headers2 });
     }
-    if (name === "ReadableStream") {
-      const headers2 = this.generateHeaders();
+    if (typeof body?.getReader === "function") {
       return new Response(body, { status: status2, headers: headers2 });
     }
     if (name === "PassThrough" || name === "Readable") {
-      const headers2 = this.generateHeaders();
       return new Response(toWeb(body), { status: status2, headers: headers2 });
     }
-    return this.json(body);
+    headers2.set("content-type", "application/json");
+    return new Response(JSON.stringify(body), { status: status2, headers: headers2 });
   }
 };
-var status = (...args) => new Reply().status(...args);
-var headers = (...args) => new Reply().headers(...args);
-var type = (...args) => new Reply().type(...args);
-var download = (...args) => new Reply().download(...args);
-var cookies = (...args) => new Reply().cookies(...args);
-var send = (...args) => new Reply().send(...args);
-var json = (...args) => new Reply().json(...args);
-var file = (...args) => new Reply().file(...args);
-var redirect = (...args) => new Reply().redirect(...args);
-var view = (...args) => new Reply().view(...args);
+var r = () => new Reply();
+var status = (...args) => r().status(...args);
+var headers = (...args) => r().headers(...args);
+var type = (...args) => r().type(...args);
+var download = (...args) => r().download(...args);
+var cookies = (...args) => r().cookies(...args);
+var send = (...args) => r().send(...args);
+var json = (...args) => r().json(...args);
+var file = (...args) => r().file(...args);
+var redirect = (...args) => r().redirect(...args);
 
 // src/auth/providers/github.ts
 var oauth = async (code) => {
@@ -364,14 +355,30 @@ var github_default = { login, callback };
 var providers_default = { email: email_default, github: github_default };
 
 // src/auth/parseAuthOptions.ts
+var defaultRedirect = "/user";
+function defaultCleanUser(fullUser) {
+  const { password: _password, ...user } = fullUser;
+  return user;
+}
+var providersKeys = Object.keys(providers_default);
+function getProviders(provider) {
+  if (typeof provider === "string") {
+    provider = provider.split("|");
+  }
+  const invalidProvider = provider.find((p) => !providersKeys.includes(p));
+  if (invalidProvider) {
+    throw new Error(
+      `Provider "${invalidProvider}" not found, available ones are "${providersKeys.join('", "')}"`
+    );
+  }
+  return provider;
+}
 function parseAuthOptions(auth2, all) {
   if (!auth2) return null;
   if (typeof auth2 === "string") {
-    const [strategy, provider] = auth2.split(":");
-    auth2 = { strategy, provider };
-  }
-  if (typeof auth2.provider === "string") {
-    auth2.provider = auth2.provider.split("|").filter(Boolean);
+    const [strategy2, providerRaw] = auth2.split(":");
+    const provider2 = providerRaw && providerRaw.split("|");
+    auth2 = { strategy: strategy2, provider: provider2 };
   }
   if (!auth2.strategy) {
     throw new Error("Auth options needs a strategy");
@@ -379,31 +386,32 @@ function parseAuthOptions(auth2, all) {
   if (!auth2.strategy.length) {
     throw new Error("Auth options needs a strategy");
   }
+  const strategy = auth2.strategy;
   if (!auth2.provider || !auth2.provider.length) {
     throw new Error("Auth options needs a provider");
   }
-  const providerNotFound = auth2.provider.find((p) => !providers_default[p]);
-  if (providerNotFound) {
-    throw new Error(
-      `Provider "${providerNotFound}" not found, available ones are "${Object.keys(providers_default).join('", "')}"`
-    );
+  const provider = getProviders(auth2.provider);
+  const redirect2 = auth2.redirect || defaultRedirect;
+  const cleanUser = auth2.cleanUser || defaultCleanUser;
+  if (!auth2.store && !all.store) {
+    throw new Error("Need a userStore store for Auth");
   }
-  if (!auth2.session && all.store) {
-    auth2.session = all.store.prefix("auth:");
+  if (!auth2.session && !all.store) {
+    throw new Error("Need a sessionStore store for Auth");
   }
-  if (!auth2.store && all.store) {
-    auth2.store = all.store.prefix("user:");
-  }
-  if (!auth2.cleanUser) {
-    auth2.cleanUser = (fullUser) => {
-      const { password: _password, ...user } = fullUser;
-      return user;
-    };
-  }
-  if (!auth2.redirect) {
-    auth2.redirect = "/user";
-  }
-  return auth2;
+  const store = auth2.store || all.store.prefix("user:");
+  const session2 = auth2.session || all.store.prefix("auth:");
+  return {
+    // Base main configuration
+    strategy,
+    provider,
+    // Extra configuration
+    redirect: redirect2,
+    cleanUser,
+    // Stores for the auth session and users
+    store,
+    session: session2
+  };
 }
 
 // src/helpers/bucket.ts
@@ -660,20 +668,52 @@ function cors(config2, origin = "") {
 }
 
 // src/helpers/createCookies.ts
-function createCookies(cookies2) {
-  if (!cookies2 || !Object.keys(cookies2).length) return [];
-  return Object.entries(cookies2).map(([key, val]) => {
-    if (!val) {
-      val = { value: "", expires: (/* @__PURE__ */ new Date(0)).toUTCString() };
-    }
-    if (typeof val === "string") {
-      val = { value: val };
-    }
-    const { value, path: path2, expires } = val;
-    const pathPart = `;Path=${path2 || "/"}`;
-    const expiresPart = expires ? `;Expires=${expires}` : "";
-    return `${key}=${value || ""}${pathPart}${expiresPart}`;
-  });
+var EXPIRED2 = (/* @__PURE__ */ new Date(0)).toUTCString();
+var times = /(-?(?:\d+\.?\d*|\d*\.?\d+)(?:e[-+]?\d+)?)\s*([\p{L}]*)/iu;
+parse.millisecond = parse.ms = 1e-3;
+parse.second = parse.sec = parse.s = parse[""] = 1;
+parse.minute = parse.min = parse.m = parse.s * 60;
+parse.hour = parse.hr = parse.h = parse.m * 60;
+parse.day = parse.d = parse.h * 24;
+parse.week = parse.wk = parse.w = parse.d * 7;
+parse.year = parse.yr = parse.y = parse.d * 365.25;
+parse.month = parse.b = parse.y / 12;
+function parse(str) {
+  if (str === null || str === void 0) return null;
+  if (typeof str === "number") return str;
+  str = str.toLowerCase().replace(/[,_]/g, "");
+  const [_, value, units] = times.exec(str) || [];
+  if (!units) return null;
+  const unitValue = parse[units] || parse[units.replace(/s$/, "")];
+  if (!unitValue) return null;
+  const result = unitValue * parseFloat(value);
+  return Math.abs(Math.round(result * 1e3));
+}
+function normalizeExpires(expires) {
+  if (expires === null || expires === void 0) return void 0;
+  if (expires === 0) return EXPIRED2;
+  if (typeof expires === "string") {
+    if (/^[\d._]+\w+$/.test(expires)) {
+      return new Date(Date.now() + parse(expires)).toUTCString();
+    } else {
+      return expires;
+    }
+  }
+  if (typeof expires === "number") {
+    return new Date(Date.now() + expires).toUTCString();
+  }
+  if (expires instanceof Date) {
+    return expires.toUTCString();
+  }
+  return void 0;
+}
+function createCookies(key, val) {
+  if (val.value === null) val.expires = EXPIRED2;
+  const { value, path: path2, expires } = val;
+  const pathPart = `;Path=${path2 || "/"}`;
+  const expiresStr = normalizeExpires(expires);
+  const expiresPart = typeof expires !== "undefined" ? `;Expires=${expiresStr}` : "";
+  return `${key}=${value || ""}${pathPart}${expiresPart}`;
 }
 
 // src/helpers/createWebsocket.ts
@@ -789,7 +829,7 @@ async function parseResponse(out, ctx) {
   }
   if (Object.keys(ctx.session || {}).length) {
     if (!ctx.options.session?.store) {
-      throw ServerError_default.NO_STORE({});
+      throw ServerError_default.NO_STORE();
     }
     if (!ctx.cookies.session) {
       ctx.res.cookies.session = createId();
@@ -1378,7 +1418,7 @@ var encode = (str = "") => {
 };
 var getConfig = (routes) => {
   const config2 = routes.find(
-    (r) => typeof r !== "string" && typeof r !== "function" && typeof r === "object"
+    (r2) => typeof r2 !== "string" && typeof r2 !== "function" && typeof r2 === "object"
   );
   if (!config2) return {};
   if (config2.tags) {
@@ -1527,13 +1567,13 @@ var openapi_default = async (ctx) => {
 
 // src/middle/timer.ts
 var createTime = () => {
-  const times = [["init", performance.now()]];
-  const time = (name) => times.push([name, performance.now()]);
-  time.times = times;
+  const times2 = [["init", performance.now()]];
+  const time = (name) => times2.push([name, performance.now()]);
+  time.times = times2;
   time.headers = () => {
-    const r = (t) => Math.round(t);
-    const times2 = time.times;
-    const timing = times2.slice(1).map(([name, time2], i) => `${name};dur=${r(time2 - times2[i][1])}`).join(", ");
+    const r2 = (t) => Math.round(t);
+    const times3 = time.times;
+    const timing = times3.slice(1).map(([name, time2], i) => `${name};dur=${r2(time2 - times3[i][1])}`).join(", ");
     return timing;
   };
   return time;
@@ -1833,39 +1873,27 @@ function isSerializable(body) {
 }
 function ServerTest(app) {
   const port = app.settings.port;
-  const fetch2 = async (path2, method, options = {}) => {
-    try {
-      if (!options.headers) options.headers = {};
-      if (isSerializable(options.body)) {
-        options.headers["content-type"] = "application/json";
-        options.body = JSON.stringify(options.body);
-      }
-      const res = await app.fetch(
-        new Request(`http://localhost:${port}${path2}`, {
-          method,
-          ...options
-        })
-      );
-      const headers2 = parseHeaders_default(res.headers);
-      let body;
-      if (headers2["content-type"]?.includes("application/json")) {
-        body = await res.json();
-      } else {
-        body = await res.text();
-      }
-      return { status: res.status, headers: headers2, body };
-    } catch (error) {
-      return { status: 500, headers: {}, body: error.message };
-    }
+  const fetch2 = async (method, path2, options = {}) => {
+    if (!options.headers) options.headers = {};
+    if (isSerializable(options.body)) {
+      options.headers["content-type"] = "application/json";
+      options.body = JSON.stringify(options.body);
+    }
+    return await app.fetch(
+      new Request(`http://localhost:${port}${path2}`, {
+        method,
+        ...options
+      })
+    );
   };
   return {
-    get: (path2, options) => fetch2(path2, "get", options),
-    head: (path2, options) => fetch2(path2, "head", options),
-    post: (path2, body, options) => fetch2(path2, "post", { body, ...options }),
-    put: (path2, body, options) => fetch2(path2, "put", { body, ...options }),
-    patch: (path2, body, options) => fetch2(path2, "patch", { body, ...options }),
-    delete: (path2, options) => fetch2(path2, "delete", options),
-    options: (path2, options) => fetch2(path2, "options", options)
+    get: (path2, options) => fetch2("get", path2, options),
+    head: (path2, options) => fetch2("head", path2, options),
+    post: (path2, body, options) => fetch2("post", path2, { body, ...options }),
+    put: (path2, body, options) => fetch2("put", path2, { body, ...options }),
+    patch: (path2, body, options) => fetch2("patch", path2, { body, ...options }),
+    delete: (path2, options) => fetch2("delete", path2, options),
+    options: (path2, options) => fetch2("options", path2, options)
   };
 }
 
@@ -1934,7 +1962,6 @@ function server(options = {}) {
   return new Server(options).self();
 }
 export {
-  Reply,
   Server,
   ServerError_default as ServerError,
   cookies,
@@ -1947,6 +1974,5 @@ export {
   router,
   send,
   status,
-  type,
-  view
+  type
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@server/next",
-  "version": "0.27.1",
+  "version": "0.27.4",
   "description": "A fully-fledged web server with routing, file uploads, sessions, static files, schema validation, websockets, testing, etc.",
   "homepage": "https://server-js.com/",
   "repository": "https://github.com/franciscop/server-next.git",
@@ -20,7 +20,7 @@
     "build": "bunx tsup src/index.ts --format esm --dts --out-dir . --target node24",
     "start": "bun test --watch",
     "lint": "npx @biomejs/biome lint ./src --skip=lint/suspicious/noExplicitAny --skip=lint/style/noParameterAssign  --skip=lint/suspicious/noConfusingVoidType",
-    "types": "npx tsc --noEmit src/index.ts",
+    "types": "npx tsc --noEmit",
     "test": "npm run test:bun && tsc --noEmit",
     "test:bun": "bun test",
     "test:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js"
@@ -34,11 +34,13 @@
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
+    "index.d.ts",
     "src/jsx/"
   ],
   "exports": {
     ".": "./index.js",
-    "./jsx-runtime": "./src/jsx/jsx-dev-runtime.js",
+    "./index.d.ts": "./index.d.ts",
+    "./jsx-runtime": "./src/jsx/jsx-runtime.js",
     "./jsx-dev-runtime": "./src/jsx/jsx-dev-runtime.js"
   },
   "devDependencies": {

package/src/jsx/jsx-dev-runtime.js

@@ -1,91 +1 @@
-const entities = {
-  "&": "&",
-  "<": "&lt;",
-  ">": "&gt;",
-  '"': "&quot;",
-};
-
-const encode = (str = "") => {
-  if (typeof str === "number") str = String(str);
-  if (typeof str !== "string") return "";
-  return str.replace(/[&<>"]/g, (tag) => entities[tag]);
-};
-
-const SELFCLOSE = new Set(
-  "area,base,br,col,embed,hr,img,input,link,meta,source,track,wbr".split(","),
-);
-
-const altAttrs = {
-  classname: "class",
-};
-
-// "" and 0 are valid children, false and null and undefined are not
-const isValidChild = (child) => child || child === "" || child === 0;
-
-const escapeCSS = (value) => String(value).replace(/[<>&"'`]/g, "\\$&");
-
-const minifyCss = (str) =>
-  str
-    .replace(/\s+/g, " ")
-    .replace(/(?!<")\/\*[^*]+\*\/(?!")/g, "")
-    .replace(/(\w|\*) (\{)/g, "$1$2")
-    .replace(/(\}) (\w|\*)/g, "$1$2")
-    .replace(/(\{) (\w)/g, "$1$2")
-    .replace(/(\w)(:) /g, "$1$2")
-    .replace(/(;) (\})/g, "$1$2")
-    .replace(/(;) (\w)/g, "$1$2")
-    .replace(/;(\})/g, "$1")
-    .replace(/(\w), (\w)/g, "$1,$2")
-    .replace(/(\w), (\w)/g, "$1,$2")
-    .replace(/(\{) (\w)/g, "$1$2")
-    .trim();
-
-const jsx = (tag, { children, ...props }) => {
-  if (typeof tag === "function") return tag({ children, ...props });
-
-  if (tag === "script" && children) {
-    const src = children;
-    children = () => src;
-  }
-
-  if (tag === "style" && children && typeof children === "string") {
-    const src = minifyCss(escapeCSS(children));
-    children = () => src;
-  }
-
-  if (props?.dangerouslySetInnerHTML) {
-    children = () => props.dangerouslySetInnerHTML.__html;
-  }
-
-  if (!isValidChild(children)) children = [];
-  if (typeof children === "string") children = [children];
-
-  children = (Array.isArray(children) ? children : [children])
-    .flat()
-    .map((c) => (typeof c === "function" ? c() : encode(c)))
-    .join("");
-
-  if (!tag) return () => children;
-
-  let attrStr = Object.entries(props || {})
-    .filter(([k]) => k !== "dangerouslySetInnerHTML")
-    .filter(([k, v]) => !/on[A-Z]/.test(k) && typeof v !== "function")
-    .filter(([, v]) => v !== false)
-    .map(([k, v]) =>
-      v === true
-        ? altAttrs[k.toLowerCase()] || encode(k)
-        : `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(String(v))}"`,
-    )
-    .join(" ");
-
-  if (attrStr) attrStr = ` ${attrStr}`;
-
-  if (SELFCLOSE.has(tag)) return () => `<${tag}${attrStr} />`;
-
-  const doctype = tag === "html" ? "<!DOCTYPE html>" : "";
-  return () => `${doctype}<${tag}${attrStr}>${children}</${tag}>`;
-};
-
-const Fragment = "";
-
-export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };
+export * from "./jsx-runtime.js";

package/src/jsx/jsx-runtime.js

@@ -0,0 +1,91 @@
+const entities = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+};
+
+const encode = (str = "") => {
+  if (typeof str === "number") str = String(str);
+  if (typeof str !== "string") return "";
+  return str.replace(/[&<>"]/g, (tag) => entities[tag]);
+};
+
+const SELFCLOSE = new Set(
+  "area,base,br,col,embed,hr,img,input,link,meta,source,track,wbr".split(","),
+);
+
+const altAttrs = {
+  classname: "class",
+};
+
+// "" and 0 are valid children, false and null and undefined are not
+const isValidChild = (child) => child || child === "" || child === 0;
+
+const escapeCSS = (value) => String(value).replace(/[<>&"'`]/g, "\\$&");
+
+const minifyCss = (str) =>
+  str
+    .replace(/\s+/g, " ")
+    .replace(/(?!<")\/\*[^*]+\*\/(?!")/g, "")
+    .replace(/(\w|\*) (\{)/g, "$1$2")
+    .replace(/(\}) (\w|\*)/g, "$1$2")
+    .replace(/(\{) (\w)/g, "$1$2")
+    .replace(/(\w)(:) /g, "$1$2")
+    .replace(/(;) (\})/g, "$1$2")
+    .replace(/(;) (\w)/g, "$1$2")
+    .replace(/;(\})/g, "$1")
+    .replace(/(\w), (\w)/g, "$1,$2")
+    .replace(/(\w), (\w)/g, "$1,$2")
+    .replace(/(\{) (\w)/g, "$1$2")
+    .trim();
+
+const jsx = (tag, { children, ...props }) => {
+  if (typeof tag === "function") return tag({ children, ...props });
+
+  if (tag === "script" && children) {
+    const src = children;
+    children = () => src;
+  }
+
+  if (tag === "style" && children && typeof children === "string") {
+    const src = minifyCss(escapeCSS(children));
+    children = () => src;
+  }
+
+  if (props?.dangerouslySetInnerHTML) {
+    children = () => props.dangerouslySetInnerHTML.__html;
+  }
+
+  if (!isValidChild(children)) children = [];
+  if (typeof children === "string") children = [children];
+
+  children = (Array.isArray(children) ? children : [children])
+    .flat()
+    .map((c) => (typeof c === "function" ? c() : encode(c)))
+    .join("");
+
+  if (!tag) return () => children;
+
+  let attrStr = Object.entries(props || {})
+    .filter(([k]) => k !== "dangerouslySetInnerHTML")
+    .filter(([k, v]) => !/on[A-Z]/.test(k) && typeof v !== "function")
+    .filter(([, v]) => v !== false)
+    .map(([k, v]) =>
+      v === true
+        ? altAttrs[k.toLowerCase()] || encode(k)
+        : `${altAttrs[k.toLowerCase()] || encode(k)}="${encode(String(v))}"`,
+    )
+    .join(" ");
+
+  if (attrStr) attrStr = ` ${attrStr}`;
+
+  if (SELFCLOSE.has(tag)) return () => `<${tag}${attrStr} />`;
+
+  const doctype = tag === "html" ? "<!DOCTYPE html>" : "";
+  return () => `${doctype}<${tag}${attrStr}>${children}</${tag}>`;
+};
+
+const Fragment = "";
+
+export { jsx, jsx as jsxs, jsx as jsxDEV, Fragment };