feat(h3framework): Added support for h3 framework

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
+### Adds
+
+-   Support for h3 freamwork.
+
 ## [9.2.3] - 2022-06-03
 
 -   Changes `getUserMetadata` to return `any` type for metadata so that it's easier to use.

add-ts-no-check.js

@@ -8,7 +8,7 @@ glob(__dirname + "/lib/**/*.d.ts", (err, files) => {
         let lines = contents.split("\n");
         let newContents = `// @ts-nocheck`;
         for (line of lines) {
-            if (line.match(/\/\/\/\ \<reference\ types\=\"(express|koa|loopback|hapi|aws|fastify)/g) === null) {
+            if (line.match(/\/\/\/\ \<reference\ types\=\"(express|koa|loopback|hapi|aws|fastify|h3)/g) === null) {
                 newContents += `\n${line}`;
             }
         }

framework/h3/index.d.ts

@@ -0,0 +1,3 @@
+export * from "../../lib/build/framework/h3";
+import * as _default from "../../lib/build/framework/h3";
+export default _default;

framework/h3/index.js

@@ -0,0 +1,6 @@
+"use strict";
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+exports.__esModule = true;
+__export(require("../../lib/build/framework/h3"));

lib/build/framework/awsLambda/framework.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import type {
     APIGatewayProxyEventV2,
     APIGatewayProxyEvent,

lib/build/framework/awsLambda/index.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 export type { SessionEvent, SessionEventV2 } from "./framework";
 export declare const middleware: (
     handler?: import("aws-lambda").Handler<any, any> | undefined

lib/build/framework/constants.d.ts

@@ -1,2 +1 @@
-// @ts-nocheck
 export declare const COOKIE_HEADER = "Set-Cookie";

lib/build/framework/express/framework.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import type { Request, Response, NextFunction } from "express";
 import type { HTTPMethod } from "../../types";
 import { BaseRequest } from "../request";

lib/build/framework/express/index.d.ts

@@ -1,4 +1,4 @@
-// @ts-nocheck
+/// <reference types="express" />
 export type { SessionRequest } from "./framework";
 export declare const middleware: () => (
     req: import("express").Request,

lib/build/framework/fastify/framework.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /// <reference types="node" />
 import type { FastifyRequest as OriginalFastifyRequest, FastifyReply, FastifyPluginCallback } from "fastify";
 import type { HTTPMethod } from "../../types";

lib/build/framework/fastify/index.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /// <reference types="node" />
 export type { SessionRequest } from "./framework";
 export declare const plugin: import("fastify").FastifyPluginCallback<Record<never, never>, import("http").Server>;

lib/build/framework/h3/framework.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="node" />
+import { H3Event } from "h3";
+import type { IncomingMessage, ServerResponse } from "http";
+import { SessionContainerInterface } from "../../recipe/session/types";
+import { BaseRequest } from "../request";
+import { BaseResponse } from "../response";
+import { Framework } from "../types";
+export declare class H3Request extends BaseRequest {
+    private request;
+    constructor(request: IncomingMessage);
+    getCookieValue: (key: string) => string | undefined;
+    getFormData: () => Promise<any>;
+    getMethod: () => import("../../types").HTTPMethod;
+    getHeaderValue: (key: string) => string | undefined;
+    getOriginalURL: () => string;
+    getKeyValueFromQuery: (key: string) => string | undefined;
+    getJSONBody: () => Promise<any>;
+}
+export declare class H3ResponseTokens extends BaseResponse {
+    private response;
+    private statusCode;
+    constructor(response: ServerResponse);
+    sendHTMLResponse: (html: string) => void;
+    setHeader: (key: string, value: string, allowDuplicateKey: boolean) => void;
+    setCookie: (
+        key: string,
+        value: string,
+        domain: string | undefined,
+        secure: boolean,
+        httpOnly: boolean,
+        expires: number,
+        path: string,
+        sameSite: "strict" | "lax" | "none"
+    ) => void;
+    setStatusCode: (statusCode: number) => void;
+    sendJSONResponse: (content: any) => void;
+}
+export interface SessionRequest extends IncomingMessage {
+    session?: SessionContainerInterface;
+}
+export declare const middlware: () => (
+    req: IncomingMessage,
+    res: ServerResponse,
+    next: (err?: Error | undefined) => any
+) => Promise<any>;
+export declare const errorHandler: () => (event: H3Event, errorPlain: Error, statusCode: number) => Promise<void>;
+export interface H3Framework extends Framework {
+    middlware: () => (req: IncomingMessage, res: ServerResponse, next: (err?: Error) => any) => Promise<void>;
+    errorHandler: () => (event: H3Event, errorPlain: Error, statusCode: number) => Promise<void>;
+}
+export declare const H3Wrapper: H3Framework;

lib/build/framework/h3/framework.js

@@ -0,0 +1,185 @@
+"use strict";
+var __awaiter =
+    (this && this.__awaiter) ||
+    function (thisArg, _arguments, P, generator) {
+        function adopt(value) {
+            return value instanceof P
+                ? value
+                : new P(function (resolve) {
+                      resolve(value);
+                  });
+        }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) {
+                try {
+                    step(generator.next(value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function rejected(value) {
+                try {
+                    step(generator["throw"](value));
+                } catch (e) {
+                    reject(e);
+                }
+            }
+            function step(result) {
+                result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+            }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    };
+Object.defineProperty(exports, "__esModule", { value: true });
+const h3_1 = require("h3");
+const supertokens_1 = require("../../supertokens");
+const utils_1 = require("../../utils");
+const request_1 = require("../request");
+const response_1 = require("../response");
+const utils_2 = require("../utils");
+class H3Request extends request_1.BaseRequest {
+    constructor(request) {
+        super();
+        this.getCookieValue = (key) => {
+            return utils_2.getCookieValueFromIncomingMessage(this.request, key);
+        };
+        this.getFormData = () =>
+            __awaiter(this, void 0, void 0, function* () {
+                return utils_2.useRawBody(this.request);
+            });
+        this.getMethod = () => {
+            return utils_1.normaliseHttpMethod(this.request.method);
+        };
+        this.getHeaderValue = (key) => {
+            return utils_2.getHeaderValueFromIncomingMessage(this.request, key);
+        };
+        this.getOriginalURL = () => {
+            return this.request.url;
+        };
+        this.getKeyValueFromQuery = (key) => {
+            let path = this.request.url || "/";
+            const queryIndex = path.lastIndexOf("?");
+            if (queryIndex > -1) {
+                const queryArray = path.substring(queryIndex + 1, path.length).split("&");
+                const index = queryArray.findIndex((el) => el.includes(key));
+                if (index === -1) return undefined;
+                const value = queryArray[index].split("=")[1];
+                if (value === undefined || typeof value !== "string") {
+                    return undefined;
+                }
+                return value;
+            } else {
+                return undefined;
+            }
+        };
+        this.getJSONBody = () =>
+            __awaiter(this, void 0, void 0, function* () {
+                return yield utils_2.useBody(this.request);
+            });
+        this.original = request;
+        this.request = request;
+    }
+}
+exports.H3Request = H3Request;
+class H3ResponseTokens extends response_1.BaseResponse {
+    constructor(response) {
+        super();
+        this.sendHTMLResponse = (html) => {
+            if (this.response.writable) {
+                this.response.setHeader("Content-Type", "text/html");
+                this.response.statusCode = this.statusCode;
+                this.response.end(html);
+            }
+        };
+        this.setHeader = (key, value, allowDuplicateKey) => {
+            try {
+                const allheaders = this.response.getHeaders();
+                let existingValue = allheaders[key];
+                // we have the this.response.header for compatibility with nextJS
+                if (existingValue === undefined) {
+                    this.response.setHeader(key, value);
+                } else if (allowDuplicateKey) {
+                    this.response.setHeader(key, existingValue + ", " + value);
+                } else {
+                    // we overwrite the current one with the new one
+                    this.response.setHeader(key, value);
+                }
+            } catch (err) {
+                throw new Error("Error while setting header with key: " + key + " and value: " + value);
+            }
+        };
+        this.setCookie = (key, value, domain, secure, httpOnly, expires, path, sameSite) => {
+            utils_2.setCookieForServerResponse(
+                this.response,
+                key,
+                value,
+                domain,
+                secure,
+                httpOnly,
+                expires,
+                path,
+                sameSite
+            );
+        };
+        this.setStatusCode = (statusCode) => {
+            if (this.response.writable) {
+                this.statusCode = statusCode;
+            }
+        };
+        this.sendJSONResponse = (content) => {
+            if (this.response.writable) {
+                content = JSON.stringify(content);
+                this.response.setHeader("Content-Type", "application/json");
+                this.response.statusCode = this.statusCode;
+                this.response.end(content, "utf-8");
+            }
+        };
+        this.original = response;
+        this.response = response;
+        this.statusCode = 200;
+    }
+}
+exports.H3ResponseTokens = H3ResponseTokens;
+exports.middlware = () => {
+    return (req, res, next) =>
+        __awaiter(void 0, void 0, void 0, function* () {
+            let supertokens;
+            const request = new H3Request(req);
+            const response = new H3ResponseTokens(res);
+            try {
+                supertokens = supertokens_1.default.getInstanceOrThrowError();
+                const result = yield supertokens.middleware(request, response);
+                if (!result) {
+                    return next();
+                }
+            } catch (err) {
+                if (supertokens) {
+                    try {
+                        yield supertokens.errorHandler(err, request, response);
+                    } catch (_a) {
+                        next(err);
+                    }
+                } else {
+                    next(err);
+                }
+            }
+        });
+};
+exports.errorHandler = () => {
+    return (event, errorPlain, statusCode) =>
+        __awaiter(void 0, void 0, void 0, function* () {
+            const error = h3_1.createError(errorPlain);
+            error.statusCode = statusCode;
+            h3_1.sendError(event, error);
+        });
+};
+exports.H3Wrapper = {
+    middlware: exports.middlware,
+    errorHandler: exports.errorHandler,
+    wrapRequest: (unwrapped) => {
+        return new H3Request(unwrapped.req);
+    },
+    wrapResponse: (unwrapped) => {
+        return new H3ResponseTokens(unwrapped.res);
+    },
+};

lib/build/framework/h3/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+export type { SessionRequest } from "./framework";
+export declare const middleware: () => (
+    req: import("http").IncomingMessage,
+    res: import("http").ServerResponse,
+    next: (err?: Error | undefined) => any
+) => Promise<void>;
+export declare const errorHandler: () => (
+    event: import("h3").H3Event,
+    errorPlain: Error,
+    statusCode: number
+) => Promise<void>;
+export declare const wrapRequest: (unwrapped: any) => import("..").BaseRequest;
+export declare const wrapResponse: (unwrapped: any) => import("..").BaseResponse;

lib/build/framework/h3/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const framework_1 = require("./framework");
+exports.middleware = framework_1.H3Wrapper.middlware;
+exports.errorHandler = framework_1.H3Wrapper.errorHandler;
+exports.wrapRequest = framework_1.H3Wrapper.wrapRequest;
+exports.wrapResponse = framework_1.H3Wrapper.wrapResponse;

lib/build/framework/h3/types.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { ServerResponse, IncomingMessage } from "http";
+export interface Event {
+    res: ServerResponse;
+    req: IncomingMessage;
+}

lib/build/framework/h3/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

lib/build/framework/hapi/framework.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import type { Request, ResponseToolkit, Plugin, ResponseObject } from "@hapi/hapi";
 import type { HTTPMethod } from "../../types";
 import { BaseRequest } from "../request";

lib/build/framework/hapi/index.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 export type { SessionRequest } from "./framework";
 export declare const plugin: import("@hapi/hapi").Plugin<{}>;
 export declare const wrapRequest: (unwrapped: any) => import("..").BaseRequest;

lib/build/framework/index.d.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 export { BaseRequest } from "./request";
 export { BaseResponse } from "./response";
 import * as expressFramework from "./express";
@@ -7,13 +6,15 @@ import * as hapiFramework from "./hapi";
 import * as loopbackFramework from "./loopback";
 import * as koaFramework from "./koa";
 import * as awsLambdaFramework from "./awsLambda";
+import * as h3Framework from "./h3";
 declare const _default: {
     express: typeof expressFramework;
     fastify: typeof fastifyFramework;
     hapi: typeof hapiFramework;
     loopback: typeof loopbackFramework;
     koa: typeof koaFramework;
     awsLambda: typeof awsLambdaFramework;
+    h3: typeof h3Framework;
 };
 export default _default;
 export declare let express: typeof expressFramework;
@@ -22,3 +23,4 @@ export declare let hapi: typeof hapiFramework;
 export declare let loopback: typeof loopbackFramework;
 export declare let koa: typeof koaFramework;
 export declare let awsLambda: typeof awsLambdaFramework;
+export declare let h3: typeof h3Framework;