@mxpicture/gcp-functions 0.1.0

package/dist/cjs/index.js

@@ -0,0 +1,42 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+// A default export can help some consumers using require()
+const _all = __importStar(require("./lib"));
+exports.default = _all;

package/dist/cjs/lib.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FunctionHandlers"), exports);
+__exportStar(require("./handler/IHttpHandlerItem"), exports);
+__exportStar(require("./handler/HttpHandler"), exports);
+__exportStar(require("./common/firebase"), exports);
+__exportStar(require("./common/http"), exports);
+__exportStar(require("./common/types.common"), exports);
+__exportStar(require("./api/IApi"), exports);
+__exportStar(require("./store/IStore"), exports);
+__exportStar(require("./store/types.store"), exports);

package/dist/cjs/package.js

@@ -0,0 +1,21 @@
+"use strict";
+// eslint-disable-next-line @typescript-eslint/triple-slash-reference
+/// <reference path="./types/express.d.ts" />
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export your public types/exports so this file becomes the root .d.ts for the package.
+// Adjust the relative path if your source layout differs.
+__exportStar(require("./lib"), exports);

package/dist/cjs/store/IStore.js

@@ -0,0 +1,107 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IStore = exports.convertDocObject = void 0;
+const firebase_js_1 = require("../common/firebase.js");
+const uuid = __importStar(require("short-uuid"));
+const convertDocObject = (doc) => {
+    if (typeof doc.data !== "function")
+        return doc;
+    return {
+        ...doc.data(),
+        createTime: doc.createTime,
+        updateTime: doc.updateTime,
+        id: doc.id,
+    };
+};
+exports.convertDocObject = convertDocObject;
+class IStore {
+    constructor(collectionName) {
+        this.collectionName = collectionName;
+    }
+    db() {
+        if (!this._db)
+            this._db = firebase_js_1.db
+                .collection(`picpad.${this.collectionName}`)
+                .withConverter(this.createConverter());
+        return this._db;
+    }
+    async query(p) {
+        const snapshot = p && p.parentId
+            ? await this.refByParent(p.parentId).get()
+            : await this.db().get();
+        return snapshot.docs.map((exports.convertDocObject));
+    }
+    async count(p) {
+        const snapshot = p && p.parentId
+            ? await this.refByParent(p.parentId).count().get()
+            : await this.db().count().get();
+        return snapshot.data().count;
+    }
+    ref(id) {
+        return this.db().doc(id);
+    }
+    async get(id) {
+        const snapshot = await this.ref(id).get();
+        if (!snapshot.exists)
+            throw new Error(`Id ${id} does not exist`);
+        return (0, exports.convertDocObject)(snapshot);
+    }
+    async exists(id) {
+        return (await this.ref(id).get()).exists;
+    }
+    async create(doc) {
+        doc.id = uuid.generate();
+        const ref = this.ref(doc.id);
+        await ref.set(doc);
+        return this.get(doc.id);
+    }
+    async update(id, doc) {
+        const entry = this.ref(id);
+        await entry.update({ ...doc });
+        return this.get(id);
+    }
+    async delete(...ids) {
+        await Promise.all(ids.map((id) => this.ref(id).delete()));
+    }
+    async deleteByParent(parentId) {
+        const snapshot = await this.refByParent(parentId).get();
+        await this.delete(...snapshot.docs.map((doc) => doc.id));
+    }
+    refByParent(parentId) {
+        return this.db().where("parentId", "==", parentId);
+    }
+}
+exports.IStore = IStore;

package/dist/cjs/store/types.store.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storePersistSchema = exports.storeBaseSchema = exports.storePersistSchemaShape = exports.storeBaseSchemaShape = void 0;
+const zod_1 = require("zod");
+exports.storeBaseSchemaShape = {
+    id: zod_1.z.string().optional(),
+    createTime: zod_1.z.date().optional(),
+    updateTime: zod_1.z.date().optional(),
+};
+exports.storePersistSchemaShape = {
+    ...exports.storeBaseSchemaShape,
+    id: zod_1.z.string(),
+};
+exports.storeBaseSchema = zod_1.z.object(exports.storeBaseSchemaShape);
+exports.storePersistSchema = zod_1.z.object(exports.storePersistSchemaShape);

package/dist/esm/FunctionHandlers.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionHandlers = void 0;
+class FunctionHandlers {
+    constructor() {
+        this.items = {};
+    }
+    add(handler) {
+        this.items[handler.name] = handler;
+    }
+    functions() {
+        const result = {};
+        for (const [key, item] of Object.entries(this.items))
+            result[key] = item.setup();
+        return result;
+    }
+}
+exports.FunctionHandlers = FunctionHandlers;

package/dist/esm/api/IApi.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IApi = void 0;
+const zod_meta_1 = require("@mxpicture/zod-meta");
+class IApi {
+    constructor(store, shape) {
+        this.store = store;
+        this.shape = shape;
+    }
+    metaItems() {
+        return new zod_meta_1.Meta(this.shape).items();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async create(doc, params) {
+        const storeDoc = await this.store.create(doc);
+        return this.fromStore(storeDoc);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async get(id, params) {
+        const storeDoc = await this.store.get(id);
+        return this.fromStore(storeDoc);
+    }
+    async query(params) {
+        const storeDocs = await this.store.query(params);
+        return await Promise.all(storeDocs.map((s) => this.fromStore(s)));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async count(params) {
+        return this.store.count();
+    }
+    async update(id, doc, 
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    params) {
+        let storeDoc = await this.toStore(doc);
+        storeDoc = await this.store.update(id, storeDoc);
+        return this.fromStore(storeDoc);
+    }
+    async updatePartial(id, doc) {
+        const storeDoc = await this.toStorePartial(doc);
+        await this.store.update(id, storeDoc);
+        return this.get(id);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async delete(id, params) {
+        await this.store.delete(id);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    async exists(id, params) {
+        return this.store.exists(id);
+    }
+}
+exports.IApi = IApi;

package/dist/esm/common/firebase.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.round = exports.verifyConnectionToken = exports.sessionLogout = exports.sessionLogin = exports.verifyAuthAll = exports.verifySessionCookie = exports.verifyToken = exports.extractToken = exports.db = exports.app = void 0;
+const auth_1 = require("firebase-admin/auth");
+const firestore_1 = require("firebase-admin/firestore");
+const app_1 = require("firebase-admin/app");
+exports.app = (0, app_1.initializeApp)();
+exports.db = (0, firestore_1.getFirestore)();
+const extractToken = (request) => {
+    const auth = request.headers["authorization"];
+    if (!auth)
+        return;
+    // Read the ID Token from the Authorization header.
+    if (auth && auth.startsWith("Bearer "))
+        return auth.split("Bearer ")[1];
+    // Read the ID Token from cookie.
+    if (request.cookies)
+        return request.cookies.__session;
+    return;
+};
+exports.extractToken = extractToken;
+// Express middleware that validates Firebase ID Tokens passed in the Authorization HTTP header.
+// The Firebase ID token needs to be passed as a Bearer token in the Authorization HTTP header like this:
+// `Authorization: Bearer <Firebase ID Token>`.
+// when decoded successfully, the ID Token content will be added as `request.user`.
+const verifyToken = (request, response, next) => {
+    const token = (0, exports.extractToken)(request);
+    if (!token) {
+        response
+            .status(401)
+            .json({ status: "unauthorized", message: "Unauthorized" });
+        return;
+    }
+    (0, auth_1.getAuth)()
+        .verifyIdToken(token)
+        .then((decodedIdToken) => {
+        // Only process if the user just signed in in the last 5 minutes.
+        if (Date.now() / 1000 - decodedIdToken.auth_time >= 5 * 60)
+            return response.status(401).json({
+                status: "unauthorized",
+                message: "Recent sign in required!",
+            });
+        request.user = decodedIdToken;
+        request.headers["x-id-token"] = token;
+        return next();
+    }, (error) => {
+        response.status(401).json({
+            status: "unauthorized",
+            message: JSON.stringify(error),
+        });
+    })
+        .catch((error) => {
+        response.status(401).json({
+            status: "unauthorized",
+            message: `Error while verifying Firebase ID token: ${error}`,
+        });
+    });
+};
+exports.verifyToken = verifyToken;
+const verifySessionCookie = (request, response, next) => {
+    const sessionCookie = 
+    // request.cookies.session ||
+    // request.cookies.zsession ||
+    request.cookies.__session || request.headers.zsession || "";
+    // Verify the session cookie. In this case an additional check is added to detect
+    // if the user's Firebase session was revoked, user deleted/disabled, etc.
+    (0, auth_1.getAuth)()
+        .verifySessionCookie(sessionCookie, true /** checkRevoked */)
+        .then(() => {
+        next();
+    }, (error) => {
+        response.status(401).json({
+            status: "unauthorized",
+            message: JSON.stringify(error),
+        });
+    })
+        .catch((error) => {
+        response.status(401).json({
+            status: "unauthorized",
+            message: JSON.stringify(error),
+        });
+    });
+};
+exports.verifySessionCookie = verifySessionCookie;
+const verifyAuthAll = (token) => {
+    return (request, response, next) => {
+        const t = token();
+        // connection token
+        const id = request.headers["x-connection-token"];
+        if (typeof id === "string") {
+            if (id === t)
+                return next();
+            return response.status(401).json({
+                status: "unauthorized",
+                message: "",
+            });
+        }
+        // message connection token
+        if ((0, exports.extractToken)(request))
+            return (0, exports.verifyToken)(request, response, next);
+        // session cookie
+        return (0, exports.verifySessionCookie)(request, response, next);
+    };
+};
+exports.verifyAuthAll = verifyAuthAll;
+const sessionLogin = (request, response) => {
+    // Get the ID token passed and the CSRF token.
+    const idToken = `${request.headers["x-id-token"]}`;
+    // Set session expiration to 5 days.
+    const expiresIn = 60 * 60 * 24 * 5 * 1000;
+    // Create the session cookie. This will also verify the ID token in the process.
+    // The session cookie will have the same claims as the ID token.
+    // To only allow session cookie setting on recent sign-in, auth_time in ID token
+    // can be checked to ensure user was recently signed in before creating a session cookie.
+    (0, auth_1.getAuth)()
+        .createSessionCookie(idToken, { expiresIn })
+        .then((sessionCookie) => {
+        // Set cookie policy for session cookie.
+        // cloud functions will only allow __session (issue only deployed)
+        response.cookie("__session", sessionCookie, {
+            maxAge: expiresIn,
+            httpOnly: true,
+            secure: true,
+        });
+        // const now = new Date();
+        // const zsession =
+        //   "zsession=" +
+        //   sessionCookie +
+        //   "; expires=" +
+        //   now.toUTCString() +
+        //   "; path=/";
+        response.end(JSON.stringify({
+            status: "success",
+            // zsession: zsession,
+        }));
+    }, (error) => {
+        response.status(401).json({
+            status: "unauthorized",
+            message: JSON.stringify(error),
+        });
+    })
+        .catch((error) => {
+        response.status(401).json({
+            status: "unauthorized",
+            message: JSON.stringify(error),
+        });
+    });
+};
+exports.sessionLogin = sessionLogin;
+const sessionLogout = (request, response) => {
+    response.clearCookie("session");
+    response.clearCookie("zsession");
+    response.clearCookie("__session");
+};
+exports.sessionLogout = sessionLogout;
+const verifyConnectionToken = (token) => {
+    return async (request, response, next) => {
+        const id = request.headers["x-connection-token"];
+        if (id === token()) {
+            next();
+            return;
+        }
+        response.status(401).json({
+            status: "unauthorized",
+            message: "",
+        });
+    };
+};
+exports.verifyConnectionToken = verifyConnectionToken;
+const round = (value, digits = 3) => {
+    const factor = Math.pow(10, digits);
+    return Math.round(value * factor) / factor;
+};
+exports.round = round;

package/dist/esm/common/http.js

@@ -0,0 +1,147 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixRequestBody = exports.hasBody = exports.contentstream = void 0;
+const querystring = __importStar(require("querystring"));
+const zlib_1 = require("zlib");
+const zlib = __importStar(require("zlib"));
+const http_errors_1 = __importDefault(require("http-errors"));
+// export const handleErrorMessage = (
+//   response: express.Response,
+//   error: unknown,
+//   code: number = StatusCodes.BAD_REQUEST,
+// ) => {
+//   // eslint-disable-next-line @typescript-eslint/no-explicit-any
+//   const ae = error as any;
+//   const result = { message: "" };
+//   if (error instanceof Error) result.message = error.message;
+//   else if (typeof error === "string") result.message = error;
+//   else if (ae.message) result.message = ae.message;
+//   else if (ae.payload) {
+//     if (ae.payload.message && typeof ae.payload.message === "string")
+//       result.message = ae.payload.message;
+//     else if (typeof ae.payload === "string") result.message = ae.payload;
+//   } else result.message = "unknown";
+//   return response.status(code).json(result);
+// };
+const hasBrotliSupport = "createBrotliDecompress" in zlib;
+/**
+ * Get the content stream of the request.
+ *
+ * @param {object} req
+ * @param {function} debug
+ * @param {boolean} [inflate=true]
+ * @return {object}
+ * @api private
+ */
+const contentstream = (req, inflate, debug = console) => {
+    const encoding = (req.headers["content-encoding"] || "identity").toLowerCase();
+    // const length = req.headers["content-length"];
+    let stream;
+    debug?.log('content-encoding "%s"', encoding);
+    if (inflate === false && encoding !== "identity") {
+        throw (0, http_errors_1.default)(415, "content encoding unsupported", {
+            encoding: encoding,
+            type: "encoding.unsupported",
+        });
+    }
+    switch (encoding) {
+        case "deflate":
+            stream = (0, zlib_1.createInflate)();
+            debug?.log("inflate body");
+            req.pipe(stream);
+            break;
+        case "gzip":
+            stream = (0, zlib_1.createGunzip)();
+            debug?.log("gunzip body");
+            req.pipe(stream);
+            break;
+        case "identity":
+            stream = req;
+            // stream.length = length;
+            break;
+        case "br":
+            if (hasBrotliSupport) {
+                stream = (0, zlib_1.createBrotliDecompress)();
+                debug?.log("brotli decompress body");
+                req.pipe(stream);
+            }
+            break;
+    }
+    if (stream === undefined) {
+        throw (0, http_errors_1.default)(415, 'unsupported content encoding "' + encoding + '"', {
+            encoding: encoding,
+            type: "encoding.unsupported",
+        });
+    }
+    return stream;
+};
+exports.contentstream = contentstream;
+const hasBody = (request) => {
+    const contentType = request.headers["content-type"];
+    return contentType
+        ? contentType.includes("application/json") ||
+            contentType.includes("+json") ||
+            contentType.includes("application/x-www-form-urlencoded")
+        : false;
+};
+exports.hasBody = hasBody;
+/**
+ * Fix proxied body if bodyParser is involved.
+ */
+const fixRequestBody = (proxyReq, requestBody) => {
+    if (!requestBody) {
+        return;
+    }
+    const contentType = proxyReq.getHeader("Content-Type");
+    const writeBody = (bodyData) => {
+        // deepcode ignore ContentLengthInCode: bodyParser fix
+        proxyReq.setHeader("Content-Length", `'${Buffer.byteLength(bodyData)}'`);
+        proxyReq.write(bodyData);
+    };
+    if (contentType &&
+        (contentType.includes("application/json") || contentType.includes("+json"))) {
+        writeBody(JSON.stringify(requestBody));
+    }
+    if (contentType &&
+        contentType.includes("application/x-www-form-urlencoded") &&
+        !Array.isArray(requestBody)) {
+        writeBody(querystring.stringify(requestBody));
+    }
+};
+exports.fixRequestBody = fixRequestBody;

package/dist/esm/common/types.common.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.castHttpError = exports.PrimitiveType = exports.HttpMethod = exports.HttpProtocol = void 0;
+var HttpProtocol;
+(function (HttpProtocol) {
+    HttpProtocol["http"] = "http";
+    HttpProtocol["https"] = "https";
+})(HttpProtocol || (exports.HttpProtocol = HttpProtocol = {}));
+var HttpMethod;
+(function (HttpMethod) {
+    HttpMethod["POST"] = "POST";
+    HttpMethod["PATCH"] = "PATCH";
+    HttpMethod["PUT"] = "PUT";
+    HttpMethod["GET"] = "GET";
+    HttpMethod["DELETE"] = "DELETE";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+var PrimitiveType;
+(function (PrimitiveType) {
+    PrimitiveType["string"] = "string";
+    PrimitiveType["number"] = "number";
+    PrimitiveType["boolean"] = "boolean";
+})(PrimitiveType || (exports.PrimitiveType = PrimitiveType = {}));
+const castHttpError = (error) => {
+    if (!error.message || typeof error.message !== "string")
+        return;
+    if (error.context && typeof error.message !== "string")
+        return;
+    return { message: error.message, context: error.context };
+};
+exports.castHttpError = castHttpError;

package/dist/esm/handler/HttpHandler.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpHandler = void 0;
+const express_1 = __importDefault(require("express"));
+const cookie_parser_1 = __importDefault(require("cookie-parser"));
+const cors_1 = __importDefault(require("cors"));
+const https_1 = require("firebase-functions/v2/https");
+// export interface HandlerEnv {
+//   connectionToken: () => string;
+// }
+class HttpHandler {
+    constructor(name) {
+        this.name = name;
+        this.corsAllowList = [];
+        this.items = [];
+        this.exp = (0, express_1.default)();
+    }
+    add(...items) {
+        this.items.push(...items);
+        return this;
+    }
+    baseSetup() {
+        this.exp.use((0, cors_1.default)({ credentials: true, origin: true }));
+        this.exp.use((0, cookie_parser_1.default)());
+        this.exp.disable("x-powered-by");
+        // this.exp.use(verifySessionCookie); // todo verify token (maybe connection token)
+    }
+    setup() {
+        this.baseSetup();
+        for (const item of this.items)
+            item.setup(this.exp);
+        return this.createFunction();
+    }
+    createFunction() {
+        return (0, https_1.onRequest)({ cors: [/firebase\.com$/, /web\.app$/] }, this.exp);
+    }
+}
+exports.HttpHandler = HttpHandler;