@veecode-platform/backstage-plugin-kong-service-manager-backend-dynamic 1.0.1

package/node_modules/express-promise-router/lib/express-promise-router.js

@@ -0,0 +1,131 @@
+"use strict";
+var Router = require("express").Router;
+var flattenDeep = require("lodash.flattendeep");
+var isPromise = require("is-promise");
+
+var wrapHandler = function (handler) {
+  if ("function" !== typeof handler) {
+    var type = Object.prototype.toString.call(handler);
+    var msg = "Expected a callback function but got a " + type;
+    throw new Error(msg);
+  }
+
+  var handleReturn = function (args) {
+    // Find the next function from the arguments
+    var next = args.slice(-1)[0];
+
+    // When calling router.param, the last parameter is a string, not next.
+    // If so, the next should be the one before it.
+    if ("string" === typeof next) {
+      next = args.slice(-2)[0];
+    }
+
+    // Call the route
+    var ret = handler.apply(null, args);
+
+    // If it doesn't return a promise, we exit.
+    if (!isPromise(ret)) {
+      return;
+    }
+
+    // Since we got a promise, we handle calling next
+    Promise.resolve(ret).then(
+      function (d) {
+        if (d === "next") {
+          next();
+        } else if (d === "route") {
+          next("route");
+        }
+      },
+      function (err) {
+        if (!err) {
+          err = new Error(
+            "returned promise was rejected but did not have a reason",
+          );
+        }
+        next(err);
+      },
+    );
+  };
+
+  if (handler.length === 4) {
+    // Preserve the original handler function name. See #146.
+    const wrapperObj = {
+      [handler.name]: function (err, req, res, next) {
+        handleReturn([err, req, res, next]);
+      },
+    };
+    return wrapperObj[handler.name];
+  }
+
+  // Preserve the original handler function name. See #146.
+  const wrapperObj = {
+    [handler.name]: function (req, res, next) {
+      handleReturn([req, res, next]);
+    },
+  };
+
+  // Correctly include router handler context. See #306.
+  if (handler.name === "router") {
+    Object.assign(wrapperObj[handler.name], handler);
+  }
+
+  return wrapperObj[handler.name];
+};
+
+var wrapMethods = function (instanceToWrap, isRoute) {
+  var toConcat = isRoute ? ["all"] : ["use", "all", "param"];
+
+  var methods = require("methods").concat(toConcat);
+
+  methods.forEach(function (method) {
+    var original = "__" + method;
+    instanceToWrap[original] = instanceToWrap[method];
+    instanceToWrap[method] = function () {
+      // Manipulating arguments directly is discouraged
+      var args = new Array(arguments.length);
+      for (var i = 0; i < arguments.length; ++i) {
+        args[i] = arguments[i];
+      }
+
+      // Grab the first parameter out in case it's a route or array of routes.
+      var first = null;
+      if (
+        "string" === typeof args[0] ||
+        args[0] instanceof RegExp ||
+        (Array.isArray(args[0]) &&
+          ("string" === typeof args[0][0] || args[0][0] instanceof RegExp))
+      ) {
+        first = args[0];
+        args = args.slice(1);
+      }
+
+      args = flattenDeep(args).map(function (arg) {
+        return wrapHandler(arg);
+      });
+
+      // If we have a route path or something, push it in front
+      if (first) {
+        args.unshift(first);
+      }
+
+      return instanceToWrap[original].apply(this, args);
+    };
+  });
+
+  return instanceToWrap;
+};
+
+var PromiseRouter = function (path) {
+  var me = wrapMethods(new Router(path));
+
+  me.__route = me.route;
+  me.route = function (path) {
+    return wrapMethods(me.__route(path), true);
+  };
+
+  return me;
+};
+
+PromiseRouter.default = PromiseRouter;
+module.exports = PromiseRouter;

package/node_modules/express-promise-router/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "express-promise-router",
+  "version": "4.1.1",
+  "main": "lib/express-promise-router.js",
+  "description": "A lightweight wrapper for Express 4's Router that allows middleware to return promises",
+  "homepage": "https://github.com/express-promise-router/express-promise-router",
+  "bugs": "https://github.com/express-promise-router/express-promise-router/issues",
+  "author": {
+    "name": "Moritz Mahringer",
+    "email": "contact@mahringer.dev"
+  },
+  "contributors": [
+    {
+      "name": "Alex Whitney",
+      "email": "alex.whitney@gatech.edu"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/express-promise-router/express-promise-router"
+  },
+  "engines": {
+    "node": ">=10"
+  },
+  "licenses": [
+    {
+      "type": "MIT"
+    }
+  ],
+  "keywords": [
+    "express",
+    "promise",
+    "router"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "is-promise": "^4.0.0",
+    "lodash.flattendeep": "^4.0.0",
+    "methods": "^1.0.0"
+  },
+  "peerDependencies": {
+    "express": "^4.0.0",
+    "@types/express": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/express": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@babel/core": "7.16.0",
+    "@babel/plugin-transform-modules-commonjs": "7.16.0",
+    "@changesets/cli": "2.18.1",
+    "@mormahr/typescript-definition-tester": "1.1.0",
+    "@types/express": "4.17.13",
+    "chai": "4.3.4",
+    "eslint": "7.32.0",
+    "eslint-config-prettier": "8.3.0",
+    "express": "4.17.1",
+    "husky": "6.0.0",
+    "lint-staged": "11.1.2",
+    "mocha": "8.4.0",
+    "prettier": "2.5.0",
+    "request": "2.88.2",
+    "request-promise": "4.2.6",
+    "sinon": "12.0.1",
+    "typescript": "4.5.2"
+  },
+  "types": "index.d.ts",
+  "scripts": {
+    "lint": "eslint {lib,test}/**/*.js",
+    "unit-tests": "mocha test/*.test.js",
+    "test": "npm run-script lint && npm run-script unit-tests"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.js": "eslint --cache --fix",
+    "*.{js,ts,yml,yaml,json,json5,css,md,.eslintrc}": "prettier --write"
+  }
+}

package/node_modules/express-promise-router/test/.eslintrc

@@ -0,0 +1,8 @@
+{
+  "env": {
+    "mocha": true
+  },
+  "rules": {
+    "no-unused-vars": 0
+  }
+}

package/node_modules/express-promise-router/test/babel.test.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var resolve = require("path").resolve;
+var assert = require("chai").assert;
+var spawnBabel = require("./util/launch-utils").spawnBabel;
+var GET = require("./util/http-utils").GET;
+
+describe("Babel", function () {
+  it("should run the example and respond", function (done) {
+    this.timeout(5000);
+    var js_file = resolve(__dirname, "./test-resources/babel-base-case.js");
+    var target = spawnBabel(js_file);
+    var called = false;
+
+    target.stdout.on("data", function (data) {
+      if (data.toString().indexOf("START") === -1) {
+        return;
+      }
+
+      GET("/").then(function () {
+        called = true;
+        target.kill("SIGINT");
+      });
+    });
+
+    target.stderr.on("data", function (data) {
+      console.error(data.toString());
+    });
+
+    target.on("close", function () {
+      assert(called);
+      done();
+    });
+  });
+});

package/node_modules/express-promise-router/test/commonjs.test.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var resolve = require("path").resolve;
+var assert = require("chai").assert;
+var spawnJavaScript = require("./util/launch-utils").spawnJavaScript;
+var GET = require("./util/http-utils").GET;
+
+describe("CommonJs", function () {
+  it("should run the example and respond", function (done) {
+    this.timeout(5000);
+    var js_file = resolve(__dirname, "./test-resources/commonjs-base-case.js");
+    var target = spawnJavaScript(js_file);
+    var called = false;
+
+    target.stdout.on("data", function (data) {
+      if (data.toString().indexOf("START") === -1) {
+        return;
+      }
+
+      GET("/").then(function () {
+        called = true;
+        target.kill("SIGINT");
+      });
+    });
+
+    target.stderr.on("data", function (data) {
+      console.error(data.toString());
+    });
+
+    target.on("close", function () {
+      assert(called);
+      done();
+    });
+  });
+});

package/node_modules/express-promise-router/test/express-promise-router.nested-route.test.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var assert = require("chai").assert;
+var sinon = require("sinon");
+
+var PromiseRouter = require("../lib/express-promise-router.js");
+
+describe("Nested routes..", () => {
+  it("Should correctly provide handle contexts when nested routes are created", () => {
+    const router = PromiseRouter();
+    const subRouter = PromiseRouter();
+
+    subRouter.get("/users", (req, res) => res.send("ok"));
+    router.use("/api", subRouter);
+
+    assert.exists(router.stack[0].handle.stack);
+  });
+});

package/node_modules/express-promise-router/test/express-promise-router.route.test.js

@@ -0,0 +1,353 @@
+"use strict";
+
+var assert = require("chai").assert;
+var sinon = require("sinon");
+var express = require("express");
+var GET = require("./util/http-utils").GET;
+
+var delay = function (method, payload) {
+  setTimeout(function () {
+    method(payload);
+  }, 10);
+};
+
+var PromiseRouter = require("../lib/express-promise-router.js");
+
+describe("new Router().route(...)", function () {
+  var app;
+  var serverListening;
+  var server;
+  var router;
+
+  var bootstrap = function (router) {
+    app = express();
+    app.use("/", router);
+
+    if (serverListening) {
+      throw "already bootstrapped";
+    }
+
+    serverListening = new Promise(function (resolve, reject) {
+      server = app.listen(12345, function (err) {
+        if (err) {
+          reject(err);
+        } else {
+          resolve();
+        }
+      });
+    });
+
+    return serverListening;
+  };
+
+  beforeEach(function () {
+    router = new PromiseRouter();
+  });
+
+  afterEach(function () {
+    if (serverListening) {
+      return serverListening.then(function () {
+        server.close();
+        app = undefined;
+        server = undefined;
+        serverListening = undefined;
+      });
+    }
+  });
+
+  it("should call next with an error when a returned promise is rejected", function () {
+    var callback = sinon.spy();
+
+    router.route("/foo").get(function () {
+      return new Promise(function (resolve, reject) {
+        delay(reject, "some error");
+      });
+    });
+    router.use(function (err, req, res, next) {
+      assert.equal("some error", err);
+      callback();
+      res.send();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(callback.calledOnce);
+      });
+  });
+
+  it('should call next without an error when a returned promise is resolved with "next"', function () {
+    var errorCallback = sinon.spy();
+    var nextCallback = sinon.spy();
+
+    router
+      .route("/foo")
+      .get(function () {
+        return new Promise(function (resolve) {
+          delay(resolve, "next");
+        });
+      })
+      .all(function (req, res) {
+        nextCallback();
+        res.send();
+      });
+    router.use(function (err, req, res, next) {
+      errorCallback();
+      next();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(errorCallback.notCalled);
+        assert(nextCallback.calledOnce);
+      });
+  });
+
+  it('should not call next when a returned promise is resolved with anything other than "route" or "next"', function () {
+    var callback = sinon.spy();
+
+    router.route("/foo").get(function (req, res) {
+      return new Promise(function (resolve) {
+        res.send();
+        delay(resolve, "something");
+      });
+    });
+    router.route("/bar").get(function (req, res) {
+      return new Promise(function (resolve) {
+        res.send();
+        delay(resolve, {});
+      });
+    });
+    router.use(function (req, res) {
+      callback();
+      res.send(500);
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(callback.notCalled);
+        return GET("/bar");
+      })
+      .then(function () {
+        assert(callback.notCalled);
+      });
+  });
+
+  it("should move to the next middleware when next is called without an error", function () {
+    var callback = sinon.spy();
+
+    router
+      .route("/foo")
+      .get(function (req, res, next) {
+        next();
+      })
+      .all(function (req, res, next) {
+        callback();
+        res.send();
+      });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(callback.calledOnce);
+      });
+  });
+
+  it("should move to the next error handler when next is called with an error", function () {
+    var callback = sinon.spy();
+    var errorCallback = sinon.spy();
+
+    router
+      .route("/foo")
+      .get(function (req, res, next) {
+        next("an error");
+      })
+      .all(function (req, res, next) {
+        callback();
+        next();
+      });
+    router.use(function (err, req, res, next) {
+      assert.equal("an error", err);
+      errorCallback();
+      res.send();
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function () {
+        assert(errorCallback.calledOnce);
+        assert(callback.notCalled);
+      });
+  });
+
+  it("should call chained handlers in the correct order", function () {
+    var fn2 = sinon.spy(function (req, res) {
+      res.send();
+    });
+    var fn1 = sinon.spy(function () {
+      assert(fn2.notCalled);
+      return Promise.resolve("next");
+    });
+
+    router.route("/foo").get(fn1, fn2);
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it("should correctly call an array of handlers", function () {
+    var fn2 = sinon.spy(function (req, res) {
+      res.send();
+    });
+    var fn1 = sinon.spy(function () {
+      assert(fn2.notCalled);
+      return Promise.resolve("next");
+    });
+
+    router.route("/foo").get([[fn1], [fn2]]);
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it('should call next("route") if a returned promise is resolved with "route"', function () {
+    var fn1 = function () {
+      return Promise.resolve("route");
+    };
+    var fn2 = function () {
+      assert.fail();
+    };
+
+    router.route("/foo").get(fn1, fn2);
+
+    router.route("/foo").get(function (req, res) {
+      res.send();
+    });
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it("should bind to RegExp routes", function () {
+    var fn1 = function (req, res) {
+      res.send();
+    };
+
+    router.route(/^\/foo/).get(fn1);
+
+    return bootstrap(router).then(function () {
+      return GET("/foo");
+    });
+  });
+
+  it('multiple calls to handlers that have used "next" should not interfere with each other', function () {
+    var fn = sinon.spy(function (req, res, next) {
+      if (fn.calledOnce) {
+        next("error");
+      } else {
+        setTimeout(function () {
+          res.status(200).send("ok");
+        }, 15);
+      }
+    });
+    var errHandler = function (err, req, res, next) {
+      if (err === "error") {
+        res.send("fail");
+      } else {
+        next(err);
+      }
+    };
+
+    router.route("/foo").get(fn, errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "fail");
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "ok");
+      });
+  });
+
+  it("calls next if next is called even if the handler returns a promise", function () {
+    var fn = function (req, res, next) {
+      next();
+      return new Promise(function (resolve, reject) {});
+    };
+    var fn2 = function (req, res) {
+      res.send("ok");
+    };
+    var errHandler = function (err, req, res, next) {
+      res.send("error");
+    };
+
+    router.route("/foo").get(fn, fn2, errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "ok");
+      });
+  });
+
+  it("calls next with an error if the returned promise is rejected with no reason", function () {
+    var fn = function () {
+      return new Promise(function (resolve, reject) {
+        delay(reject, null);
+      });
+    };
+    var errHandler = function (err, req, res, next) {
+      res.send("error");
+    };
+
+    router.route("/foo").get(fn, errHandler);
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "error");
+      });
+  });
+
+  it("should handle resolved promises returned in req.param() calls", function () {
+    router.param("id", function () {
+      return new Promise(function (resolve) {
+        delay(resolve, "next");
+      });
+    });
+    router.route("/foo/:id").all(function (req, res) {
+      res.send("done");
+    });
+
+    return bootstrap(router)
+      .then(function () {
+        return GET("/foo/1");
+      })
+      .then(function (res) {
+        assert.equal(res.body, "done");
+      });
+  });
+});