initial commit of actions

github/codeql-action-v2/node_modules/twirp-ts/build/protoc-gen-twirp-ts/gen/gateway.js

@@ -0,0 +1,113 @@
+"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 });
+exports.getMethod = exports.genGateway = exports.Pattern = void 0;
+const fs_1 = require("fs");
+const ts_poet_1 = require("ts-poet");
+const path_to_regexp_1 = require("path-to-regexp");
+const Gateway = ts_poet_1.imp("Gateway@twirp-ts");
+const GatewayPattern = ts_poet_1.imp("Pattern@twirp-ts");
+const pathToRegexpMatch = ts_poet_1.imp("match@path-to-regexp");
+const debug = (content) => fs_1.writeFileSync(__dirname + "/debug.json", JSON.stringify(content, null, 2), "utf-8");
+var Pattern;
+(function (Pattern) {
+    Pattern["POST"] = "post";
+    Pattern["GET"] = "get";
+    Pattern["PATCH"] = "patch";
+    Pattern["PUT"] = "put";
+    Pattern["DELETE"] = "delete";
+})(Pattern = exports.Pattern || (exports.Pattern = {}));
+function genGateway(ctx, files) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const httpRoutes = files.reduce((all, current) => {
+            current.service.forEach(service => {
+                service.method.forEach((method) => {
+                    const options = ctx.interpreter.readOptions(method);
+                    if (options && options["google.api.http"]) {
+                        const httpSpec = options["google.api.http"];
+                        all.push(parseHttpOption(httpSpec, current.package || "", method.name, service.name));
+                        if (httpSpec.additional_bindings) {
+                            all.push(parseHttpOption(httpSpec.additional_bindings, current.package || "", method.name, service.name));
+                        }
+                    }
+                });
+            });
+            return all;
+        }, []);
+        return genGatewayHandler(httpRoutes).toStringWithImports();
+    });
+}
+exports.genGateway = genGateway;
+function genGatewayHandler(httpRoute) {
+    const genRoutes = (method) => httpRoute.filter(route => route.httpMethod === method).map(route => {
+        return ts_poet_1.code `
+      {
+        packageName: "${route.packageName}",
+        methodName: "${route.methodName}",
+        serviceName: "${route.serviceName}",
+        httpMethod: "${route.httpMethod}" as ${GatewayPattern},
+        matchingPath: "${route.matchingPath}{:query_string(\\\\?.*)}?",
+        matcher: ${pathToRegexpMatch}("${route.matchingPath}{:query_string(\\\\?.*)}?"),
+        bodyKey: "${route.bodyKey || ""}",
+        responseBodyKey: "${route.responseBodyKey || ""}",
+      },
+    `;
+    });
+    return ts_poet_1.code `
+  export function createGateway() {
+    return new ${Gateway}({
+      post: [${ts_poet_1.joinCode(genRoutes(Pattern.POST), { on: "\n" })}],
+      get: [${ts_poet_1.joinCode(genRoutes(Pattern.GET), { on: "\n" })}],
+      put: [${ts_poet_1.joinCode(genRoutes(Pattern.PUT), { on: "\n" })}],
+      patch: [${ts_poet_1.joinCode(genRoutes(Pattern.PATCH), { on: "\n" })}],
+      delete: [${ts_poet_1.joinCode(genRoutes(Pattern.DELETE), { on: "\n" })}],
+    })
+  }
+  `;
+}
+function parseHttpOption(httpOption, packageName, methodName, serviceName) {
+    const httpMethod = getMethod(httpOption);
+    const matchingUrl = httpOption[httpMethod];
+    const matchingPath = matcher(matchingUrl);
+    const httpRoute = {
+        packageName,
+        methodName,
+        serviceName,
+        httpMethod: httpMethod,
+        matchingPath,
+        matcher: path_to_regexp_1.match(matchingPath),
+        bodyKey: httpOption.body,
+        responseBodyKey: httpOption.responseBody,
+    };
+    return httpRoute;
+}
+function matcher(url) {
+    return url.split("/").map((urlSegment) => {
+        const matchURLParams = /{([0-9a-zA-Z_-]+)}/.exec(urlSegment);
+        if (matchURLParams && matchURLParams.length > 0) {
+            const paramName = matchURLParams[1];
+            return "{:" + paramName + "}";
+        }
+        else {
+            return urlSegment;
+        }
+    }).join("/");
+}
+function getMethod(httpSpec) {
+    const possibleMethods = ["post", "get", "patch", "put", "delete"];
+    for (const method of possibleMethods) {
+        if (method in httpSpec) {
+            return method;
+        }
+    }
+    throw new Error(`HTTP method not found`);
+}
+exports.getMethod = getMethod;