@teamkeel/functions-runtime 0.221.2 → 0.221.4

package/dist/index.d.ts

@@ -28,6 +28,12 @@ declare module '@teamkeel/functions-runtime/constraints' {
   };
   export type EnumConstraint = StringConstraint;
 
+}
+declare module '@teamkeel/functions-runtime/customFunctions/index' {
+  import { Config, CustomFunctionResponsePayload, CustomFunctionRequestPayload } from "@teamkeel/functions-runtime/types";
+  const handler: ({ method, params, id }: CustomFunctionRequestPayload, config: Config) => Promise<CustomFunctionResponsePayload>;
+  export default handler;
+
 }
 declare module '@teamkeel/functions-runtime/db/query' {
   export type SqlQueryParts = SqlQueryPart[];
@@ -94,22 +100,17 @@ declare module '@teamkeel/functions-runtime/fetch/index' {
   const _default: (uri: string, opts: RequestOpts) => Promise<import("node-fetch").Response>;
   export default _default;
 
-}
-declare module '@teamkeel/functions-runtime/handler/index' {
-  import { Config } from "@teamkeel/functions-runtime/types";
-  const startRuntimeServer: ({ functions, api }: Config) => void;
-  export default startRuntimeServer;
-
 }
 declare module '@teamkeel/functions-runtime/index' {
   import Query, { ChainableQuery } from "@teamkeel/functions-runtime/query";
   import * as QueryConstraints from "@teamkeel/functions-runtime/constraints";
   import Logger, { ConsoleTransport, Level as LogLevel } from "@teamkeel/functions-runtime/logger/index";
   import { Identity } from "@teamkeel/functions-runtime/types";
+  import handleCustomFunction from "@teamkeel/functions-runtime/customFunctions/index";
   export * from "@teamkeel/functions-runtime/returnTypes";
   export * from "@teamkeel/functions-runtime/db/resolver";
   import { queryResolverFromEnv } from "@teamkeel/functions-runtime/db/resolver";
-  export { Query, ChainableQuery, QueryConstraints, Logger, ConsoleTransport, LogLevel, Identity, queryResolverFromEnv, };
+  export { Query, ChainableQuery, QueryConstraints, Logger, ConsoleTransport, LogLevel, Identity, queryResolverFromEnv, handleCustomFunction, };
 
 }
 declare module '@teamkeel/functions-runtime/logger/index' {
@@ -239,8 +240,10 @@ declare module '@teamkeel/functions-runtime/staticAnalysis/cli' {
 
 }
 declare module '@teamkeel/functions-runtime/types' {
+  import { JSONRPCParams, JSONRPCRequest, JSONRPCResponse } from "json-rpc-2.0";
   import { StringConstraint, BooleanConstraint, NumberConstraint, DateConstraint, EnumConstraint } from "@teamkeel/functions-runtime/constraints";
   import { Logger } from "@teamkeel/functions-runtime/index";
+  import Query from "@teamkeel/functions-runtime/query";
   import { QueryResolver } from "@teamkeel/functions-runtime/db/resolver";
   export interface QueryOpts {
       tableName: string;
@@ -266,13 +269,20 @@ declare module '@teamkeel/functions-runtime/types' {
       id: string;
       email: string;
   }
+  export type CustomFunctionRequestPayload = JSONRPCRequest;
+  export type CustomFunctionResponsePayload = JSONRPCResponse;
   export interface CustomFunction {
-      call: any;
+      call: (payload: JSONRPCParams, api: API) => Promise<any>;
   }
+  type API = {
+      [apiName: string]: Query<BuiltInFields>;
+  };
+  export type Functions = Record<string, CustomFunction>;
   export interface Config {
-      functions: Record<string, CustomFunction>;
-      api: unknown;
+      functions: Functions;
+      api: API;
   }
+  export {};
 
 }
 declare module '@teamkeel/functions-runtime/util/camelCaser' {

package/dist/index.js

@@ -2572,6 +2572,943 @@ var require_source = __commonJS({
   }
 });
 
+// node_modules/json-rpc-2.0/dist/models.js
+var require_models = __commonJS({
+  "node_modules/json-rpc-2.0/dist/models.js"(exports) {
+    "use strict";
+    var __extends = exports && exports.__extends || function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2)
+            if (Object.prototype.hasOwnProperty.call(b2, p))
+              d2[p] = b2[p];
+        };
+        return extendStatics(d, b);
+      };
+      return function(d, b) {
+        if (typeof b !== "function" && b !== null)
+          throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() {
+          this.constructor = d;
+        }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.createJSONRPCNotification = exports.createJSONRPCRequest = exports.createJSONRPCSuccessResponse = exports.createJSONRPCErrorResponse = exports.JSONRPCErrorCode = exports.JSONRPCErrorException = exports.isJSONRPCResponses = exports.isJSONRPCResponse = exports.isJSONRPCRequests = exports.isJSONRPCRequest = exports.isJSONRPCID = exports.JSONRPC = void 0;
+    exports.JSONRPC = "2.0";
+    var isJSONRPCID = function(id) {
+      return typeof id === "string" || typeof id === "number" || id === null;
+    };
+    exports.isJSONRPCID = isJSONRPCID;
+    var isJSONRPCRequest = function(payload) {
+      return payload.jsonrpc === exports.JSONRPC && payload.method !== void 0 && payload.result === void 0 && payload.error === void 0;
+    };
+    exports.isJSONRPCRequest = isJSONRPCRequest;
+    var isJSONRPCRequests = function(payload) {
+      return Array.isArray(payload) && payload.every(exports.isJSONRPCRequest);
+    };
+    exports.isJSONRPCRequests = isJSONRPCRequests;
+    var isJSONRPCResponse = function(payload) {
+      return payload.jsonrpc === exports.JSONRPC && payload.id !== void 0 && (payload.result !== void 0 || payload.error !== void 0);
+    };
+    exports.isJSONRPCResponse = isJSONRPCResponse;
+    var isJSONRPCResponses = function(payload) {
+      return Array.isArray(payload) && payload.every(exports.isJSONRPCResponse);
+    };
+    exports.isJSONRPCResponses = isJSONRPCResponses;
+    var createJSONRPCError = function(code, message, data) {
+      var error = { code, message };
+      if (data != null) {
+        error.data = data;
+      }
+      return error;
+    };
+    var JSONRPCErrorException = function(_super) {
+      __extends(JSONRPCErrorException2, _super);
+      function JSONRPCErrorException2(message, code, data) {
+        var _this = _super.call(this, message) || this;
+        Object.setPrototypeOf(_this, JSONRPCErrorException2.prototype);
+        _this.code = code;
+        _this.data = data;
+        return _this;
+      }
+      JSONRPCErrorException2.prototype.toObject = function() {
+        return createJSONRPCError(this.code, this.message, this.data);
+      };
+      return JSONRPCErrorException2;
+    }(Error);
+    exports.JSONRPCErrorException = JSONRPCErrorException;
+    var JSONRPCErrorCode2;
+    (function(JSONRPCErrorCode3) {
+      JSONRPCErrorCode3[JSONRPCErrorCode3["ParseError"] = -32700] = "ParseError";
+      JSONRPCErrorCode3[JSONRPCErrorCode3["InvalidRequest"] = -32600] = "InvalidRequest";
+      JSONRPCErrorCode3[JSONRPCErrorCode3["MethodNotFound"] = -32601] = "MethodNotFound";
+      JSONRPCErrorCode3[JSONRPCErrorCode3["InvalidParams"] = -32602] = "InvalidParams";
+      JSONRPCErrorCode3[JSONRPCErrorCode3["InternalError"] = -32603] = "InternalError";
+    })(JSONRPCErrorCode2 = exports.JSONRPCErrorCode || (exports.JSONRPCErrorCode = {}));
+    var createJSONRPCErrorResponse2 = function(id, code, message, data) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        id,
+        error: createJSONRPCError(code, message, data)
+      };
+    };
+    exports.createJSONRPCErrorResponse = createJSONRPCErrorResponse2;
+    var createJSONRPCSuccessResponse2 = function(id, result) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        id,
+        result: result !== null && result !== void 0 ? result : null
+      };
+    };
+    exports.createJSONRPCSuccessResponse = createJSONRPCSuccessResponse2;
+    var createJSONRPCRequest = function(id, method, params) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        id,
+        method,
+        params
+      };
+    };
+    exports.createJSONRPCRequest = createJSONRPCRequest;
+    var createJSONRPCNotification = function(method, params) {
+      return {
+        jsonrpc: exports.JSONRPC,
+        method,
+        params
+      };
+    };
+    exports.createJSONRPCNotification = createJSONRPCNotification;
+  }
+});
+
+// node_modules/json-rpc-2.0/dist/internal.js
+var require_internal = __commonJS({
+  "node_modules/json-rpc-2.0/dist/internal.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.DefaultErrorCode = void 0;
+    exports.DefaultErrorCode = 0;
+  }
+});
+
+// node_modules/json-rpc-2.0/dist/client.js
+var require_client = __commonJS({
+  "node_modules/json-rpc-2.0/dist/client.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__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());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (_)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONRPCClient = void 0;
+    var models_1 = require_models();
+    var internal_1 = require_internal();
+    var JSONRPCClient = function() {
+      function JSONRPCClient2(_send, createID) {
+        this._send = _send;
+        this.createID = createID;
+        this.idToResolveMap = /* @__PURE__ */ new Map();
+        this.id = 0;
+      }
+      JSONRPCClient2.prototype._createID = function() {
+        if (this.createID) {
+          return this.createID();
+        } else {
+          return ++this.id;
+        }
+      };
+      JSONRPCClient2.prototype.timeout = function(delay, overrideCreateJSONRPCErrorResponse) {
+        var _this = this;
+        if (overrideCreateJSONRPCErrorResponse === void 0) {
+          overrideCreateJSONRPCErrorResponse = function(id) {
+            return (0, models_1.createJSONRPCErrorResponse)(id, internal_1.DefaultErrorCode, "Request timeout");
+          };
+        }
+        var timeoutRequest = function(ids, request) {
+          var timeoutID = setTimeout(function() {
+            ids.forEach(function(id) {
+              var resolve = _this.idToResolveMap.get(id);
+              if (resolve) {
+                _this.idToResolveMap.delete(id);
+                resolve(overrideCreateJSONRPCErrorResponse(id));
+              }
+            });
+          }, delay);
+          return request().then(function(result) {
+            clearTimeout(timeoutID);
+            return result;
+          }, function(error) {
+            clearTimeout(timeoutID);
+            return Promise.reject(error);
+          });
+        };
+        var requestAdvanced = function(request, clientParams) {
+          var ids = (!Array.isArray(request) ? [request] : request).map(function(request2) {
+            return request2.id;
+          }).filter(isDefinedAndNonNull);
+          return timeoutRequest(ids, function() {
+            return _this.requestAdvanced(request, clientParams);
+          });
+        };
+        return {
+          request: function(method, params, clientParams) {
+            var id = _this._createID();
+            return timeoutRequest([id], function() {
+              return _this.requestWithID(method, params, clientParams, id);
+            });
+          },
+          requestAdvanced: function(request, clientParams) {
+            return requestAdvanced(request, clientParams);
+          }
+        };
+      };
+      JSONRPCClient2.prototype.request = function(method, params, clientParams) {
+        return this.requestWithID(method, params, clientParams, this._createID());
+      };
+      JSONRPCClient2.prototype.requestWithID = function(method, params, clientParams, id) {
+        return __awaiter(this, void 0, void 0, function() {
+          var request, response;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                request = (0, models_1.createJSONRPCRequest)(id, method, params);
+                return [4, this.requestAdvanced(request, clientParams)];
+              case 1:
+                response = _a.sent();
+                if (response.result !== void 0 && !response.error) {
+                  return [2, response.result];
+                } else if (response.result === void 0 && response.error) {
+                  return [2, Promise.reject(new models_1.JSONRPCErrorException(response.error.message, response.error.code, response.error.data))];
+                } else {
+                  return [2, Promise.reject(new Error("An unexpected error occurred"))];
+                }
+                return [2];
+            }
+          });
+        });
+      };
+      JSONRPCClient2.prototype.requestAdvanced = function(requests, clientParams) {
+        var _this = this;
+        var areRequestsOriginallyArray = Array.isArray(requests);
+        if (!Array.isArray(requests)) {
+          requests = [requests];
+        }
+        var requestsWithID = requests.filter(function(request) {
+          return isDefinedAndNonNull(request.id);
+        });
+        var promises = requestsWithID.map(function(request) {
+          return new Promise(function(resolve) {
+            return _this.idToResolveMap.set(request.id, resolve);
+          });
+        });
+        var promise = Promise.all(promises).then(function(responses) {
+          if (areRequestsOriginallyArray || !responses.length) {
+            return responses;
+          } else {
+            return responses[0];
+          }
+        });
+        return this.send(areRequestsOriginallyArray ? requests : requests[0], clientParams).then(function() {
+          return promise;
+        }, function(error) {
+          requestsWithID.forEach(function(request) {
+            _this.receive((0, models_1.createJSONRPCErrorResponse)(request.id, internal_1.DefaultErrorCode, error && error.message || "Failed to send a request"));
+          });
+          return promise;
+        });
+      };
+      JSONRPCClient2.prototype.notify = function(method, params, clientParams) {
+        var request = (0, models_1.createJSONRPCNotification)(method, params);
+        this.send(request, clientParams).then(void 0, function() {
+          return void 0;
+        });
+      };
+      JSONRPCClient2.prototype.send = function(payload, clientParams) {
+        return this._send(payload, clientParams);
+      };
+      JSONRPCClient2.prototype.rejectAllPendingRequests = function(message) {
+        this.idToResolveMap.forEach(function(resolve, id) {
+          return resolve((0, models_1.createJSONRPCErrorResponse)(id, internal_1.DefaultErrorCode, message));
+        });
+        this.idToResolveMap.clear();
+      };
+      JSONRPCClient2.prototype.receive = function(responses) {
+        var _this = this;
+        if (!Array.isArray(responses)) {
+          responses = [responses];
+        }
+        responses.forEach(function(response) {
+          var resolve = _this.idToResolveMap.get(response.id);
+          if (resolve) {
+            _this.idToResolveMap.delete(response.id);
+            resolve(response);
+          }
+        });
+      };
+      return JSONRPCClient2;
+    }();
+    exports.JSONRPCClient = JSONRPCClient;
+    var isDefinedAndNonNull = function(value) {
+      return value !== void 0 && value !== null;
+    };
+  }
+});
+
+// node_modules/json-rpc-2.0/dist/server.js
+var require_server = __commonJS({
+  "node_modules/json-rpc-2.0/dist/server.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s)
+            if (Object.prototype.hasOwnProperty.call(s, p))
+              t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    var __awaiter = exports && exports.__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());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (_)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONRPCServer = void 0;
+    var models_1 = require_models();
+    var internal_1 = require_internal();
+    var createParseErrorResponse = function() {
+      return (0, models_1.createJSONRPCErrorResponse)(null, models_1.JSONRPCErrorCode.ParseError, "Parse error");
+    };
+    var createInvalidRequestResponse = function(request) {
+      return (0, models_1.createJSONRPCErrorResponse)((0, models_1.isJSONRPCID)(request.id) ? request.id : null, models_1.JSONRPCErrorCode.InvalidRequest, "Invalid Request");
+    };
+    var createMethodNotFoundResponse = function(id) {
+      return (0, models_1.createJSONRPCErrorResponse)(id, models_1.JSONRPCErrorCode.MethodNotFound, "Method not found");
+    };
+    var JSONRPCServer = function() {
+      function JSONRPCServer2(options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a;
+        this.mapErrorToJSONRPCErrorResponse = defaultMapErrorToJSONRPCErrorResponse;
+        this.nameToMethodDictionary = {};
+        this.middleware = null;
+        this.errorListener = (_a = options.errorListener) !== null && _a !== void 0 ? _a : console.warn;
+      }
+      JSONRPCServer2.prototype.hasMethod = function(name) {
+        return !!this.nameToMethodDictionary[name];
+      };
+      JSONRPCServer2.prototype.addMethod = function(name, method) {
+        this.addMethodAdvanced(name, this.toJSONRPCMethod(method));
+      };
+      JSONRPCServer2.prototype.toJSONRPCMethod = function(method) {
+        return function(request, serverParams) {
+          var response = method(request.params, serverParams);
+          return Promise.resolve(response).then(function(result) {
+            return mapResultToJSONRPCResponse(request.id, result);
+          });
+        };
+      };
+      JSONRPCServer2.prototype.addMethodAdvanced = function(name, method) {
+        var _a;
+        this.nameToMethodDictionary = __assign(__assign({}, this.nameToMethodDictionary), (_a = {}, _a[name] = method, _a));
+      };
+      JSONRPCServer2.prototype.receiveJSON = function(json, serverParams) {
+        var request = this.tryParseRequestJSON(json);
+        if (request) {
+          return this.receive(request, serverParams);
+        } else {
+          return Promise.resolve(createParseErrorResponse());
+        }
+      };
+      JSONRPCServer2.prototype.tryParseRequestJSON = function(json) {
+        try {
+          return JSON.parse(json);
+        } catch (_a) {
+          return null;
+        }
+      };
+      JSONRPCServer2.prototype.receive = function(request, serverParams) {
+        if (Array.isArray(request)) {
+          return this.receiveMultiple(request, serverParams);
+        } else {
+          return this.receiveSingle(request, serverParams);
+        }
+      };
+      JSONRPCServer2.prototype.receiveMultiple = function(requests, serverParams) {
+        return __awaiter(this, void 0, void 0, function() {
+          var responses;
+          var _this = this;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                return [4, Promise.all(requests.map(function(request) {
+                  return _this.receiveSingle(request, serverParams);
+                }))];
+              case 1:
+                responses = _a.sent().filter(isNonNull);
+                if (responses.length === 1) {
+                  return [2, responses[0]];
+                } else if (responses.length) {
+                  return [2, responses];
+                } else {
+                  return [2, null];
+                }
+                return [2];
+            }
+          });
+        });
+      };
+      JSONRPCServer2.prototype.receiveSingle = function(request, serverParams) {
+        return __awaiter(this, void 0, void 0, function() {
+          var method, response;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                method = this.nameToMethodDictionary[request.method];
+                if (!!(0, models_1.isJSONRPCRequest)(request))
+                  return [3, 1];
+                return [2, createInvalidRequestResponse(request)];
+              case 1:
+                return [4, this.callMethod(method, request, serverParams)];
+              case 2:
+                response = _a.sent();
+                return [2, mapResponse(request, response)];
+            }
+          });
+        });
+      };
+      JSONRPCServer2.prototype.applyMiddleware = function() {
+        var middlewares = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          middlewares[_i] = arguments[_i];
+        }
+        if (this.middleware) {
+          this.middleware = this.combineMiddlewares(__spreadArray([
+            this.middleware
+          ], middlewares, true));
+        } else {
+          this.middleware = this.combineMiddlewares(middlewares);
+        }
+      };
+      JSONRPCServer2.prototype.combineMiddlewares = function(middlewares) {
+        if (!middlewares.length) {
+          return null;
+        } else {
+          return middlewares.reduce(this.middlewareReducer);
+        }
+      };
+      JSONRPCServer2.prototype.middlewareReducer = function(prevMiddleware, nextMiddleware) {
+        return function(next, request, serverParams) {
+          return prevMiddleware(function(request2, serverParams2) {
+            return nextMiddleware(next, request2, serverParams2);
+          }, request, serverParams);
+        };
+      };
+      JSONRPCServer2.prototype.callMethod = function(method, request, serverParams) {
+        var _this = this;
+        var callMethod = function(request2, serverParams2) {
+          if (method) {
+            return method(request2, serverParams2);
+          } else if (request2.id !== void 0) {
+            return Promise.resolve(createMethodNotFoundResponse(request2.id));
+          } else {
+            return Promise.resolve(null);
+          }
+        };
+        var onError = function(error) {
+          _this.errorListener('An unexpected error occurred while executing "'.concat(request.method, '" JSON-RPC method:'), error);
+          return Promise.resolve(_this.mapErrorToJSONRPCErrorResponseIfNecessary(request.id, error));
+        };
+        try {
+          return (this.middleware || noopMiddleware)(callMethod, request, serverParams).then(void 0, onError);
+        } catch (error) {
+          return onError(error);
+        }
+      };
+      JSONRPCServer2.prototype.mapErrorToJSONRPCErrorResponseIfNecessary = function(id, error) {
+        if (id !== void 0) {
+          return this.mapErrorToJSONRPCErrorResponse(id, error);
+        } else {
+          return null;
+        }
+      };
+      return JSONRPCServer2;
+    }();
+    exports.JSONRPCServer = JSONRPCServer;
+    var isNonNull = function(value) {
+      return value !== null;
+    };
+    var noopMiddleware = function(next, request, serverParams) {
+      return next(request, serverParams);
+    };
+    var mapResultToJSONRPCResponse = function(id, result) {
+      if (id !== void 0) {
+        return (0, models_1.createJSONRPCSuccessResponse)(id, result);
+      } else {
+        return null;
+      }
+    };
+    var defaultMapErrorToJSONRPCErrorResponse = function(id, error) {
+      var _a;
+      var message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : "An unexpected error occurred";
+      var code = internal_1.DefaultErrorCode;
+      var data;
+      if (error instanceof models_1.JSONRPCErrorException) {
+        code = error.code;
+        data = error.data;
+      }
+      return (0, models_1.createJSONRPCErrorResponse)(id, code, message, data);
+    };
+    var mapResponse = function(request, response) {
+      if (response) {
+        return response;
+      } else if (request.id !== void 0) {
+        return (0, models_1.createJSONRPCErrorResponse)(request.id, models_1.JSONRPCErrorCode.InternalError, "Internal error");
+      } else {
+        return null;
+      }
+    };
+  }
+});
+
+// node_modules/json-rpc-2.0/dist/server-and-client.js
+var require_server_and_client = __commonJS({
+  "node_modules/json-rpc-2.0/dist/server-and-client.js"(exports) {
+    "use strict";
+    var __awaiter = exports && exports.__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());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = { label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: [] }, f, y, t, g;
+      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (_)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return { value: op[1], done: false };
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return { value: op[0] ? op[1] : void 0, done: true };
+      }
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.JSONRPCServerAndClient = void 0;
+    var models_1 = require_models();
+    var JSONRPCServerAndClient = function() {
+      function JSONRPCServerAndClient2(server, client, options) {
+        if (options === void 0) {
+          options = {};
+        }
+        var _a;
+        this.server = server;
+        this.client = client;
+        this.errorListener = (_a = options.errorListener) !== null && _a !== void 0 ? _a : console.warn;
+      }
+      JSONRPCServerAndClient2.prototype.applyServerMiddleware = function() {
+        var _a;
+        var middlewares = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+          middlewares[_i] = arguments[_i];
+        }
+        (_a = this.server).applyMiddleware.apply(_a, middlewares);
+      };
+      JSONRPCServerAndClient2.prototype.hasMethod = function(name) {
+        return this.server.hasMethod(name);
+      };
+      JSONRPCServerAndClient2.prototype.addMethod = function(name, method) {
+        this.server.addMethod(name, method);
+      };
+      JSONRPCServerAndClient2.prototype.addMethodAdvanced = function(name, method) {
+        this.server.addMethodAdvanced(name, method);
+      };
+      JSONRPCServerAndClient2.prototype.timeout = function(delay) {
+        return this.client.timeout(delay);
+      };
+      JSONRPCServerAndClient2.prototype.request = function(method, params, clientParams) {
+        return this.client.request(method, params, clientParams);
+      };
+      JSONRPCServerAndClient2.prototype.requestAdvanced = function(jsonRPCRequest, clientParams) {
+        return this.client.requestAdvanced(jsonRPCRequest, clientParams);
+      };
+      JSONRPCServerAndClient2.prototype.notify = function(method, params, clientParams) {
+        this.client.notify(method, params, clientParams);
+      };
+      JSONRPCServerAndClient2.prototype.rejectAllPendingRequests = function(message) {
+        this.client.rejectAllPendingRequests(message);
+      };
+      JSONRPCServerAndClient2.prototype.receiveAndSend = function(payload, serverParams, clientParams) {
+        return __awaiter(this, void 0, void 0, function() {
+          var response, message;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                if (!((0, models_1.isJSONRPCResponse)(payload) || (0, models_1.isJSONRPCResponses)(payload)))
+                  return [3, 1];
+                this.client.receive(payload);
+                return [3, 4];
+              case 1:
+                if (!((0, models_1.isJSONRPCRequest)(payload) || (0, models_1.isJSONRPCRequests)(payload)))
+                  return [3, 3];
+                return [4, this.server.receive(payload, serverParams)];
+              case 2:
+                response = _a.sent();
+                if (response) {
+                  return [2, this.client.send(response, clientParams)];
+                }
+                return [3, 4];
+              case 3:
+                message = "Received an invalid JSON-RPC message";
+                this.errorListener(message, payload);
+                return [2, Promise.reject(new Error(message))];
+              case 4:
+                return [2];
+            }
+          });
+        });
+      };
+      return JSONRPCServerAndClient2;
+    }();
+    exports.JSONRPCServerAndClient = JSONRPCServerAndClient;
+  }
+});
+
+// node_modules/json-rpc-2.0/dist/index.js
+var require_dist16 = __commonJS({
+  "node_modules/json-rpc-2.0/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+      if (k2 === void 0)
+        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 === void 0)
+        k2 = k;
+      o[k2] = m[k];
+    });
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m)
+        if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p))
+          __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_client(), exports);
+    __exportStar(require_models(), exports);
+    __exportStar(require_server(), exports);
+    __exportStar(require_server_and_client(), exports);
+  }
+});
+
 // node_modules/pg/node_modules/postgres-array/index.js
 var require_postgres_array = __commonJS({
   "node_modules/pg/node_modules/postgres-array/index.js"(exports) {
@@ -5436,7 +6373,7 @@ var require_parser = __commonJS({
 });
 
 // node_modules/pg-protocol/dist/index.js
-var require_dist16 = __commonJS({
+var require_dist17 = __commonJS({
   "node_modules/pg-protocol/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -5465,7 +6402,7 @@ var require_connection = __commonJS({
     "use strict";
     var net = require("net");
     var EventEmitter = require("events").EventEmitter;
-    var { parse, serialize } = require_dist16();
+    var { parse, serialize } = require_dist17();
     var flushBuffer = serialize.flush();
     var syncBuffer = serialize.sync();
     var endBuffer = serialize.end();
@@ -5642,7 +6579,7 @@ var require_connection = __commonJS({
 });
 
 // node_modules/pg/lib/client.js
-var require_client = __commonJS({
+var require_client2 = __commonJS({
   "node_modules/pg/lib/client.js"(exports, module2) {
     "use strict";
     var EventEmitter = require("events").EventEmitter;
@@ -8137,7 +9074,7 @@ var require_query2 = __commonJS({
 });
 
 // node_modules/pg/lib/native/client.js
-var require_client2 = __commonJS({
+var require_client3 = __commonJS({
   "node_modules/pg/lib/native/client.js"(exports, module2) {
     "use strict";
     var Native = require_pg_native();
@@ -8373,7 +9310,7 @@ var require_client2 = __commonJS({
 var require_native = __commonJS({
   "node_modules/pg/lib/native/index.js"(exports, module2) {
     "use strict";
-    module2.exports = require_client2();
+    module2.exports = require_client3();
   }
 });
 
@@ -8381,11 +9318,11 @@ var require_native = __commonJS({
 var require_lib2 = __commonJS({
   "node_modules/pg/lib/index.js"(exports, module2) {
     "use strict";
-    var Client = require_client();
+    var Client = require_client2();
     var defaults = require_defaults();
     var Connection = require_connection();
     var Pool = require_pg_pool();
-    var { DatabaseError } = require_dist16();
+    var { DatabaseError } = require_dist17();
     var poolFactory = (Client2) => {
       return class BoundPool extends Pool {
         constructor(options) {
@@ -9081,11 +10018,11 @@ var require_MiddlewareStack = __commonJS({
             return mw.name + ": " + (mw.tags || []).join(",");
           });
         },
-        resolve: (handler, context) => {
+        resolve: (handler2, context) => {
           for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
-            handler = middleware(handler, context);
+            handler2 = middleware(handler2, context);
           }
-          return handler;
+          return handler2;
         }
       };
       return stack;
@@ -9117,7 +10054,7 @@ var require_dist_cjs6 = __commonJS({
 });
 
 // node_modules/@aws-sdk/smithy-client/dist-cjs/client.js
-var require_client3 = __commonJS({
+var require_client4 = __commonJS({
   "node_modules/@aws-sdk/smithy-client/dist-cjs/client.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -9131,12 +10068,12 @@ var require_client3 = __commonJS({
       send(command, optionsOrCb, cb) {
         const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0;
         const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
-        const handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
+        const handler2 = command.resolveMiddleware(this.middlewareStack, this.config, options);
         if (callback) {
-          handler(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {
+          handler2(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {
           });
         } else {
-          return handler(command).then((result) => result.output);
+          return handler2(command).then((result) => result.output);
         }
       }
       destroy() {
@@ -9959,7 +10896,7 @@ var require_dist_cjs7 = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     var tslib_1 = require_tslib();
-    tslib_1.__exportStar(require_client3(), exports);
+    tslib_1.__exportStar(require_client4(), exports);
     tslib_1.__exportStar(require_command(), exports);
     tslib_1.__exportStar(require_constants(), exports);
     tslib_1.__exportStar(require_date_utils(), exports);
@@ -12872,7 +13809,7 @@ var require_version = __commonJS({
 });
 
 // node_modules/uuid/dist/index.js
-var require_dist17 = __commonJS({
+var require_dist18 = __commonJS({
   "node_modules/uuid/dist/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", {
@@ -13040,7 +13977,7 @@ var require_StandardRetryStrategy = __commonJS({
     exports.StandardRetryStrategy = void 0;
     var protocol_http_1 = require_dist_cjs8();
     var service_error_classification_1 = require_dist_cjs15();
-    var uuid_1 = require_dist17();
+    var uuid_1 = require_dist18();
     var config_1 = require_config2();
     var constants_1 = require_constants3();
     var defaultRetryQuota_1 = require_defaultRetryQuota();
@@ -20969,7 +21906,7 @@ var require_auth = __commonJS({
 });
 
 // node_modules/@aws-sdk/types/dist-cjs/client.js
-var require_client4 = __commonJS({
+var require_client5 = __commonJS({
   "node_modules/@aws-sdk/types/dist-cjs/client.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -21142,7 +22079,7 @@ var require_dist_cjs37 = __commonJS({
     var tslib_1 = require_tslib();
     tslib_1.__exportStar(require_abort(), exports);
     tslib_1.__exportStar(require_auth(), exports);
-    tslib_1.__exportStar(require_client4(), exports);
+    tslib_1.__exportStar(require_client5(), exports);
     tslib_1.__exportStar(require_command2(), exports);
     tslib_1.__exportStar(require_credentials(), exports);
     tslib_1.__exportStar(require_crypto(), exports);
@@ -22355,7 +23292,7 @@ var require_commands = __commonJS({
 });
 
 // node_modules/@aws-sdk/client-sso/dist-cjs/models/index.js
-var require_models = __commonJS({
+var require_models2 = __commonJS({
   "node_modules/@aws-sdk/client-sso/dist-cjs/models/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -22474,7 +23411,7 @@ var require_dist_cjs40 = __commonJS({
     tslib_1.__exportStar(require_SSO(), exports);
     tslib_1.__exportStar(require_SSOClient(), exports);
     tslib_1.__exportStar(require_commands(), exports);
-    tslib_1.__exportStar(require_models(), exports);
+    tslib_1.__exportStar(require_models2(), exports);
     tslib_1.__exportStar(require_pagination2(), exports);
     var SSOServiceException_1 = require_SSOServiceException();
     Object.defineProperty(exports, "SSOServiceException", { enumerable: true, get: function() {
@@ -24145,7 +25082,7 @@ var require_defaultRoleAssumers = __commonJS({
 });
 
 // node_modules/@aws-sdk/client-sts/dist-cjs/models/index.js
-var require_models2 = __commonJS({
+var require_models3 = __commonJS({
   "node_modules/@aws-sdk/client-sts/dist-cjs/models/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -24165,7 +25102,7 @@ var require_dist_cjs46 = __commonJS({
     tslib_1.__exportStar(require_STSClient(), exports);
     tslib_1.__exportStar(require_commands2(), exports);
     tslib_1.__exportStar(require_defaultRoleAssumers(), exports);
-    tslib_1.__exportStar(require_models2(), exports);
+    tslib_1.__exportStar(require_models3(), exports);
     var STSServiceException_1 = require_STSServiceException();
     Object.defineProperty(exports, "STSServiceException", { enumerable: true, get: function() {
       return STSServiceException_1.STSServiceException;
@@ -24743,7 +25680,7 @@ var require_commands3 = __commonJS({
 });
 
 // node_modules/@aws-sdk/client-rds-data/dist-cjs/models/index.js
-var require_models3 = __commonJS({
+var require_models4 = __commonJS({
   "node_modules/@aws-sdk/client-rds-data/dist-cjs/models/index.js"(exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -24762,7 +25699,7 @@ var require_dist_cjs47 = __commonJS({
     tslib_1.__exportStar(require_RDSData(), exports);
     tslib_1.__exportStar(require_RDSDataClient(), exports);
     tslib_1.__exportStar(require_commands3(), exports);
-    tslib_1.__exportStar(require_models3(), exports);
+    tslib_1.__exportStar(require_models4(), exports);
     var RDSDataServiceException_1 = require_RDSDataServiceException();
     Object.defineProperty(exports, "RDSDataServiceException", { enumerable: true, get: function() {
       return RDSDataServiceException_1.RDSDataServiceException;
@@ -24781,6 +25718,7 @@ __export(src_exports, {
   PgQueryResolver: () => PgQueryResolver,
   Query: () => Query,
   QueryConstraints: () => constraints_exports,
+  handleCustomFunction: () => customFunctions_default,
   queryResolverFromEnv: () => queryResolverFromEnv
 });
 module.exports = __toCommonJS(src_exports);
@@ -25225,6 +26163,43 @@ var Logger = class {
   }
 };
 
+// src/customFunctions/index.ts
+var import_json_rpc_2 = __toESM(require_dist16());
+var handler = async ({ method: name, params, id }, config) => {
+  const { api, functions } = config;
+  if (!(name in functions)) {
+    return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+      id,
+      import_json_rpc_2.JSONRPCErrorCode.MethodNotFound,
+      `no corresponding function found for '${name}'`
+    );
+  }
+  try {
+    const result = await functions[name].call(params, api);
+    if (!result) {
+      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+        id,
+        import_json_rpc_2.JSONRPCErrorCode.ParseError,
+        `no result returned from function '${name}'`
+      );
+    }
+    return (0, import_json_rpc_2.createJSONRPCSuccessResponse)(id, result);
+  } catch (e) {
+    let msg = "";
+    if (e instanceof Error) {
+      msg = e.message;
+    } else {
+      msg = JSON.stringify(e);
+    }
+    return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+      id,
+      import_json_rpc_2.JSONRPCErrorCode.InternalError,
+      e.message
+    );
+  }
+};
+var customFunctions_default = handler;
+
 // src/db/resolver.ts
 var import_pg = __toESM(require_lib2());
 var import_client_rds_data = __toESM(require_dist_cjs47());
@@ -25487,5 +26462,6 @@ var AwsRdsDataClientQueryResolver = class {
   PgQueryResolver,
   Query,
   QueryConstraints,
+  handleCustomFunction,
   queryResolverFromEnv
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.221.2",
+  "version": "0.221.4",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "dist/index.js",
   "scripts": {
@@ -37,6 +37,7 @@
     "chalk": "^4.1.2",
     "change-case": "^4.1.2",
     "commander": "^9.4.1",
+    "json-rpc-2.0": "^1.4.1",
     "ksuid": "^3.0.0",
     "node-fetch": "^3.2.10",
     "pg": "^8.8.0"