@teamkeel/functions-runtime 0.365.15-prerelease2 → 0.365.15-prerelease9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.365.15-prerelease2",
+  "version": "0.365.15-prerelease9",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {

package/src/consts.js

@@ -8,6 +8,7 @@ const PROTO_ACTION_TYPES = {
   READ: "OPERATION_TYPE_READ",
   WRITE: "OPERATION_TYPE_WRITE",
   JOB: "JOB_TYPE",
+  SUBSCRIBER: "SUBSCRIBER_TYPE",
 };
 
 module.exports.PROTO_ACTION_TYPES = PROTO_ACTION_TYPES;

package/src/handleJob.js

@@ -4,7 +4,6 @@ const {
   JSONRPCErrorCode,
 } = require("json-rpc-2.0");
 const { getDatabaseClient } = require("./database");
-const { tryExecuteFunction } = require("./tryExecuteFunction");
 const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
 const opentelemetry = require("@opentelemetry/api");
 const { withSpan } = require("./tracing");
@@ -54,15 +53,11 @@ async function handleJob(request, config) {
         const db = getDatabaseClient();
         const jobFunction = jobs[request.method];
         const actionType = PROTO_ACTION_TYPES.JOB;
-        const permissionFns = new Object();
-
-        // Jobs will have no permission functions yet.
-        permissionFns[request.method] = [];
 
         await tryExecuteJob(
-          { request, ctx, permissionFns, permitted, db, actionType },
+          { request, permitted, db, actionType },
           async () => {
-            // Return the job function to the containing tryExecuteFunction block
+            // Return the job function to the containing tryExecuteJob block
             return jobFunction(ctx, request.params);
           }
         );

package/src/handleJob.test.js

@@ -4,7 +4,6 @@ import { handleJob, RuntimeErrors } from "./handleJob";
 import { test, expect, beforeEach, describe } from "vitest";
 import { ModelAPI } from "./ModelAPI";
 import { useDatabase } from "./database";
-const { Permissions } = require("./permissions");
 import KSUID from "ksuid";
 
 test("when the job returns nothing as expected", async () => {

package/src/handleSubscriber.js

@@ -0,0 +1,88 @@
+const {
+  createJSONRPCErrorResponse,
+  createJSONRPCSuccessResponse,
+  JSONRPCErrorCode,
+} = require("json-rpc-2.0");
+const { getDatabaseClient } = require("./database");
+const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
+const opentelemetry = require("@opentelemetry/api");
+const { withSpan } = require("./tracing");
+const { PROTO_ACTION_TYPES } = require("./consts");
+const { tryExecuteSubscriber } = require("./tryExecuteSubscriber");
+
+// Generic handler function that is agnostic to runtime environment (local or lambda)
+// to execute a subscriber function based on the contents of a jsonrpc-2.0 payload object.
+// To read more about jsonrpc request and response shapes, please read https://www.jsonrpc.org/specification
+async function handleSubscriber(request, config) {
+  // Try to extract trace context from caller
+  const activeContext = opentelemetry.propagation.extract(
+    opentelemetry.context.active(),
+    request.meta?.tracing
+  );
+
+  // Run the whole request with the extracted context
+  return opentelemetry.context.with(activeContext, () => {
+    // Wrapping span for the whole request
+    return withSpan(request.method, async (span) => {
+      try {
+        const { createSubscriberContextAPI, subscribers } = config;
+
+        if (!(request.method in subscribers)) {
+          const message = `no corresponding subscriber found for '${request.method}'`;
+          span.setStatus({
+            code: opentelemetry.SpanStatusCode.ERROR,
+            message: message,
+          });
+          return createJSONRPCErrorResponse(
+            request.id,
+            JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+
+        // The ctx argument passed into the subscriber function.
+        const ctx = createSubscriberContextAPI({
+          meta: request.meta,
+        });
+
+        const db = getDatabaseClient();
+        const subscriberFunction = subscribers[request.method];
+        const actionType = PROTO_ACTION_TYPES.SUBSCRIBER;
+
+        await tryExecuteSubscriber({ db, actionType }, async () => {
+          // Return the subscriber function to the containing tryExecuteSubscriber block
+          return subscriberFunction(ctx, request.params);
+        });
+
+        return createJSONRPCSuccessResponse(request.id, null);
+      } catch (e) {
+        if (e instanceof Error) {
+          span.recordException(e);
+          span.setStatus({
+            code: opentelemetry.SpanStatusCode.ERROR,
+            message: e.message,
+          });
+          return errorToJSONRPCResponse(request, e);
+        }
+
+        const message = JSON.stringify(e);
+
+        span.setStatus({
+          code: opentelemetry.SpanStatusCode.ERROR,
+          message: message,
+        });
+
+        return createJSONRPCErrorResponse(
+          request.id,
+          RuntimeErrors.UnknownError,
+          message
+        );
+      }
+    });
+  });
+}
+
+module.exports = {
+  handleSubscriber,
+  RuntimeErrors,
+};

package/src/index.js

@@ -2,6 +2,7 @@ const { ModelAPI } = require("./ModelAPI");
 const { RequestHeaders } = require("./RequestHeaders");
 const { handleRequest } = require("./handleRequest");
 const { handleJob } = require("./handleJob");
+const { handleSubscriber } = require("./handleSubscriber");
 const KSUID = require("ksuid");
 const { useDatabase } = require("./database");
 const {
@@ -16,6 +17,7 @@ module.exports = {
   RequestHeaders,
   handleRequest,
   handleJob,
+  handleSubscriber,
   useDatabase,
   Permissions,
   PERMISSION_STATE,

package/src/tryExecuteJob.js

@@ -11,8 +11,9 @@ function tryExecuteJob({ db, permitted, actionType, request }, cb) {
   return withPermissions(permitted, async ({ getPermissionState }) => {
     return withDatabase(db, actionType, async ({ transaction }) => {
       await cb();
-
-      // we need to check that the final state is unpermitted. if it's not, then it means that the user has taken no explicit action to permit/deny
+      // api.permissions maintains an internal state of whether the current operation has been *explicitly* permitted/denied by the user in the course of their custom function, or if execution has already been permitted by a role based permission (evaluated in the main runtime).
+      // we need to check that the final state is permitted or unpermitted. if it's not, then it means that the user has taken no explicit action to permit/deny
+      // and therefore we default to checking the permissions defined in the schema automatically.
       if (getPermissionState() === PERMISSION_STATE.UNPERMITTED) {
         throw new PermissionError(`Not permitted to access ${request.method}`);
       }

package/src/tryExecuteSubscriber.js

@@ -0,0 +1,10 @@
+const { withDatabase } = require("./database");
+
+// tryExecuteSubscriber will create a new database connection and execute the function call.
+function tryExecuteSubscriber({ db, actionType }, cb) {
+  return withDatabase(db, actionType, async () => {
+    await cb();
+  });
+}
+
+module.exports.tryExecuteSubscriber = tryExecuteSubscriber;