@mxpicture/gcp-functions 0.1.0

package/README.md

@@ -0,0 +1,38 @@
+# gcp-functions-lib
+
+Example Node library using TypeScript and Zod. Produces:
+
+- CommonJS build at `dist/cjs`
+- ESM build at `dist/esm`
+- Type declarations at `dist/types`
+
+Usage (after npm publish or local link):
+
+ESM:
+
+```js
+import { validateUser } from "gcp-functions-lib";
+```
+
+CommonJS:
+
+```js
+const { validateUser } = require("gcp-functions-lib");
+```
+
+Build:
+
+```bash
+npm install
+npm run build
+```
+
+## Setup husky
+
+```bash
+npm install --save-dev @commitlint/config-conventional @commitlint/cli husky commitizen cz-conventional-changelog husky
+npx husky-init
+npm i
+npm run prepare
+npx husky add .husky/commit-msg 'npx --no -- commitlint --edit "$1"'
+```

package/dist/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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/cjs/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;

package/dist/cjs/handler/IHttpHandlerItem.js

@@ -0,0 +1,169 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IHttpHandlerItem = void 0;
+const raw_body_1 = __importDefault(require("raw-body"));
+const http_js_1 = require("../common/http.js");
+const https_1 = require("firebase-functions/v2/https");
+const zod_1 = require("zod");
+const types_common_js_1 = require("../common/types.common.js");
+const http_status_codes_1 = require("@mxpicture/http-status-codes");
+// export interface HandlerEnv {
+//   connectionToken: () => string;
+// }
+class IHttpHandlerItem {
+    constructor(name, api) {
+        this.name = name;
+        this.api = api;
+        this.corsAllowList = [];
+    }
+    setup(exp) {
+        exp.get(`/api/${this.name}`, async (req, res) => {
+            try {
+                const items = await this.api.query();
+                return this.httpSuccess(res, items);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.get(`/api/${this.name}_meta`, async (req, res) => {
+            try {
+                const items = this.api.metaItems();
+                return this.httpSuccess(res, items);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.get(`/api/${this.name}/:id`, async (req, res) => {
+            try {
+                const item = await this.api.get(req.params.id);
+                return this.httpSuccess(res, item);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.post(`/api/${this.name}`, async (req, res) => {
+            try {
+                const item = await this.extractBodyItem(req);
+                const valResult = await this.api.validate(item);
+                if (!valResult.success)
+                    throw (0, zod_1.treeifyError)(valResult.error);
+                const validated = await this.api.create(valResult.data);
+                return this.httpSuccess(res, validated);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+        exp.patch(`/api/${this.name}/:id`, async (req, res) => {
+            try {
+                const item = await this.extractBodyItem(req);
+                const valResult = await this.api.validatePartial(item);
+                if (!valResult.success)
+                    throw (0, zod_1.treeifyError)(valResult.error);
+                const validated = await this.api.updatePartial(req.params.id, valResult.data);
+                return this.httpSuccess(res, validated);
+            }
+            catch (error) {
+                return this.httpErrorUnnown(res, error);
+            }
+        });
+    }
+    httpSuccess(res, payload, statusCode = http_status_codes_1.StatusCodes.OK) {
+        const result = { statusCode, payload };
+        return res.status(statusCode).json(result);
+    }
+    httpError(res, errors, statusCode = http_status_codes_1.StatusCodes.BAD_REQUEST) {
+        const result = { statusCode, errors };
+        return res.status(statusCode).json(result);
+    }
+    httpErrorUnnown(res, error, statusCode = http_status_codes_1.StatusCodes.BAD_REQUEST) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const ae = error;
+        const messages = [];
+        if (error instanceof Error) {
+            messages.push({ message: error.message });
+        }
+        else if (typeof error === "string") {
+            messages.push({ message: error });
+        }
+        else if (ae.message) {
+            const err = (0, types_common_js_1.castHttpError)(ae.message);
+            if (err)
+                messages.push(err);
+        }
+        else if (ae.errors) {
+            messages.push(...this.extractZodError(ae));
+        }
+        else if (ae.payload) {
+            if (ae.payload.message && typeof ae.payload.message === "string")
+                messages.push({ message: ae.payload.message });
+            else if (typeof ae.payload === "string")
+                messages.push({ message: ae.payload });
+        }
+        else {
+            messages.push({ message: "unknown" });
+        }
+        return this.httpError(res, messages, statusCode);
+    }
+    extractZodError(tree, ...contexts) {
+        const errors = tree.errors?.map((e) => ({
+            message: e,
+            context: this.contextPath(...contexts),
+        })) ?? [];
+        const items = "items" in tree && tree.items
+            ? tree.items
+            : "properties" in tree && tree.properties
+                ? tree.properties
+                : [];
+        if (Array.isArray(items)) {
+            for (let i = 0; i < items.length; i++)
+                errors.push(...this.extractZodError(items[i], ...contexts, i));
+        }
+        else {
+            for (const [key, item] of Object.entries(items))
+                errors.push(...this.extractZodError(item, ...contexts, key));
+        }
+        return errors;
+    }
+    contextPath(...parts) {
+        const ps = parts
+            .filter((p) => !!p)
+            .map((p) => (typeof p === "string" ? p : `${p}`));
+        return ps.join(".");
+    }
+    createFunction(exp) {
+        return (0, https_1.onRequest)({ cors: [/firebase\.com$/, /web\.app$/] }, exp);
+    }
+    async extractBody(req) {
+        if (!req.headers["content-type"])
+            throw new Error("No content type provided");
+        const body = req.body ??
+            JSON.parse(await (0, raw_body_1.default)((0, http_js_1.contentstream)(req, false), {
+                encoding: "utf-8",
+            }));
+        if (Array.isArray(body))
+            return body;
+        if (body && Object.keys(body).length > 0)
+            return body;
+        throw new Error("Invalid / not existing body");
+    }
+    async extractBodyItem(req) {
+        const extr = await this.extractBody(req);
+        if (!extr || Array.isArray(extr))
+            throw new Error(`No item found in body`);
+        return extr;
+    }
+    async extractBodyItems(req) {
+        const extr = await this.extractBody(req);
+        if (!extr || !Array.isArray(extr))
+            throw new Error(`No items found in body`);
+        return extr;
+    }
+}
+exports.IHttpHandlerItem = IHttpHandlerItem;