@teamkeel/functions-runtime 0.351.0 → 0.353.0

package/package.json

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

package/src/consts.js

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

package/src/database.js

@@ -15,6 +15,7 @@ async function withDatabase(db, actionType, cb) {
   let requiresTransaction = true;
 
   switch (actionType) {
+    case PROTO_ACTION_TYPES.JOB:
     case PROTO_ACTION_TYPES.GET:
     case PROTO_ACTION_TYPES.LIST:
       requiresTransaction = false;

package/src/handleJob.js

@@ -0,0 +1,96 @@
+const {
+  createJSONRPCErrorResponse,
+  createJSONRPCSuccessResponse,
+  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");
+const { PROTO_ACTION_TYPES } = require("./consts");
+
+// Generic handler function that is agnostic to runtime environment (local or lambda)
+// to execute a job 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 handleJob(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 { createJobContextAPI, jobs } = config;
+
+        if (!(request.method in jobs)) {
+          const message = `no corresponding job 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 job function.
+        const ctx = createJobContextAPI({
+          meta: request.meta,
+        });
+
+        const permitted =
+          request.meta && request.meta.permissionState.status === "granted"
+            ? true
+            : null;
+
+        const db = getDatabaseClient();
+        const jobFunction = jobs[request.method];
+        const actionType = PROTO_ACTION_TYPES.JOB;
+
+        const result = await tryExecuteFunction(
+          { request, ctx, permitted, db, actionType },
+          async () => {
+            // Return the job function to the containing tryExecuteFunction block
+            return jobFunction(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 = {
+  handleJob,
+  RuntimeErrors,
+};

package/src/handleJob.test.js

@@ -0,0 +1,271 @@
+import { createJSONRPCRequest, JSONRPCErrorCode } from "json-rpc-2.0";
+import { sql } from "kysely";
+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 () => {
+  const config = {
+    jobs: {
+      myJob: async (ctx, inputs) => {},
+    },
+    createJobContextAPI: () => {},
+    permissions: {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "myJob", { title: "a post" });
+  rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+  expect(await handleJob(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    result: null,
+  });
+});
+
+test("when there is an unexpected error in the job", async () => {
+  const config = {
+    jobs: {
+      myJob: async (ctx, inputs) => {
+        throw new Error("oopsie daisy");
+      },
+    },
+    createJobContextAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "myJob", { title: "a post" });
+  rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+  expect(await handleJob(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: RuntimeErrors.UnknownError,
+      message: "oopsie daisy",
+    },
+  });
+});
+
+test("when there is an unexpected object thrown in the job", async () => {
+  const config = {
+    jobs: {
+      myJob: async (ctx, inputs) => {
+        throw { err: "oopsie daisy" };
+      },
+    },
+    createJobContextAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "myJob", { title: "a post" });
+  rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+  expect(await handleJob(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: RuntimeErrors.UnknownError,
+      message: '{"err":"oopsie daisy"}',
+    },
+  });
+});
+
+test("when there is no matching job for the path", async () => {
+  const config = {
+    jobs: {
+      myJob: async (ctx, inputs) => {},
+    },
+    createJobContextAPI: () => {},
+  };
+
+  const rpcReq = createJSONRPCRequest("123", "unknown", { title: "a post" });
+
+  expect(await handleJob(rpcReq, config)).toEqual({
+    id: "123",
+    jsonrpc: "2.0",
+    error: {
+      code: JSONRPCErrorCode.MethodNotFound,
+      message: "no corresponding job found for 'unknown'",
+    },
+  });
+});
+
+// The following tests assert on the various
+// jsonrpc responses that *should* happen when a user
+// writes a job that inadvertently causes a pg constraint error to occur inside of our ModelAPI class instance.
+describe("ModelAPI error handling", () => {
+  let functionConfig;
+  let db;
+
+  beforeEach(async () => {
+    process.env.KEEL_DB_CONN_TYPE = "pg";
+    process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
+
+    db = useDatabase();
+
+    await sql`
+      DROP TABLE IF EXISTS post;
+      DROP TABLE IF EXISTS author;
+  
+      CREATE TABLE author(
+        "id"               text PRIMARY KEY,
+        "name"             text NOT NULL
+      );
+    
+      CREATE TABLE post(
+        "id"            text PRIMARY KEY,
+        "title"         text NOT NULL UNIQUE,
+        "author_id"     text NOT NULL REFERENCES author(id)
+      );
+      `.execute(db);
+
+    await sql`
+        INSERT INTO author (id, name) VALUES ('123', 'Bob')
+      `.execute(db);
+
+    const models = {
+      post: new ModelAPI("post", undefined, {
+        post: {
+          author: {
+            relationshipType: "belongsTo",
+            foreignKey: "author_id",
+            referencesTable: "person",
+          },
+        },
+      }),
+    };
+
+    functionConfig = {
+      jobs: {
+        createPost: async (ctx, inputs) => {
+          const post = await models.post.create({
+            id: KSUID.randomSync().string,
+            ...inputs,
+          });
+          return post;
+        },
+        deletePost: async (ctx, inputs) => {
+          const deleted = await models.post.delete(inputs);
+          return deleted;
+        },
+      },
+      createJobContextAPI: () => ({}),
+    };
+  });
+
+  test("when kysely returns a no result error", async () => {
+    // a kysely NoResultError is thrown when attempting to delete/update a non existent record.
+    const rpcReq = createJSONRPCRequest("123", "deletePost", {
+      id: "non-existent-id",
+    });
+    rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+    expect(await handleJob(rpcReq, functionConfig)).toEqual({
+      id: "123",
+      jsonrpc: "2.0",
+      error: {
+        code: RuntimeErrors.RecordNotFoundError,
+        message: "no result",
+      },
+    });
+  });
+
+  test("when there is a not null constraint error", async () => {
+    const rpcReq = createJSONRPCRequest("123", "createPost", { title: null });
+    rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+    expect(await handleJob(rpcReq, functionConfig)).toEqual({
+      id: "123",
+      jsonrpc: "2.0",
+      error: {
+        code: RuntimeErrors.NotNullConstraintError,
+        message: 'null value in column "title" violates not-null constraint',
+        data: {
+          code: "23502",
+          column: "title",
+          detail: expect.stringContaining("Failing row contains"),
+          table: "post",
+        },
+      },
+    });
+  });
+
+  test("when there is a uniqueness constraint error", async () => {
+    await sql`
+      INSERT INTO post (id, title, author_id) values(${
+        KSUID.randomSync().string
+      }, 'hello', '123')
+      `.execute(db);
+
+    const rpcReq = createJSONRPCRequest("123", "createPost", {
+      title: "hello",
+      author_id: "something",
+    });
+    rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+    expect(await handleJob(rpcReq, functionConfig)).toEqual({
+      id: "123",
+      jsonrpc: "2.0",
+      error: {
+        code: RuntimeErrors.UniqueConstraintError,
+        message:
+          'duplicate key value violates unique constraint "post_title_key"',
+        data: {
+          code: "23505",
+          column: "title",
+          detail: "Key (title)=(hello) already exists.",
+          table: "post",
+          value: "hello",
+        },
+      },
+    });
+  });
+
+  test("when there is a null value in a foreign key column", async () => {
+    const rpcReq = createJSONRPCRequest("123", "createPost", { title: "123" });
+    rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+    expect(await handleJob(rpcReq, functionConfig)).toEqual({
+      id: "123",
+      jsonrpc: "2.0",
+      error: {
+        code: RuntimeErrors.NotNullConstraintError,
+        message:
+          'null value in column "author_id" violates not-null constraint',
+        data: {
+          code: "23502",
+          column: "author_id",
+          detail: expect.stringContaining("Failing row contains"),
+          table: "post",
+        },
+      },
+    });
+  });
+
+  test("when there is a foreign key constraint violation", async () => {
+    const rpcReq = createJSONRPCRequest("123", "createPost", {
+      title: "123",
+      author_id: "fake",
+    });
+    rpcReq.meta = { permissionState: { status: "granted", reason: "role" } };
+
+    expect(await handleJob(rpcReq, functionConfig)).toEqual({
+      id: "123",
+      jsonrpc: "2.0",
+      error: {
+        code: RuntimeErrors.ForeignKeyConstraintError,
+        message:
+          'insert or update on table "post" violates foreign key constraint "post_author_id_fkey"',
+        data: {
+          code: "23503",
+          column: "author_id",
+          detail: 'Key (author_id)=(fake) is not present in table "author".',
+          table: "post",
+          value: "fake",
+        },
+      },
+    });
+  });
+});

package/src/handleRequest.js

@@ -59,9 +59,10 @@ async function handleRequest(request, config) {
 
         const db = getDatabaseClient();
         const customFunction = functions[request.method];
+        const actionType = actionTypes[request.method];
 
         const result = await tryExecuteFunction(
-          { request, ctx, permitted, db, permissionFns, actionTypes },
+          { request, ctx, permitted, db, permissionFns, actionType },
           async () => {
             // Return the custom function to the containing tryExecuteFunction block
             // Once the custom function is called, tryExecuteFunction will check the schema's permission rules to see if it can continue committing
@@ -106,6 +107,7 @@ async function handleRequest(request, config) {
           code: opentelemetry.SpanStatusCode.ERROR,
           message: message,
         });
+
         return createJSONRPCErrorResponse(
           request.id,
           RuntimeErrors.UnknownError,

package/src/index.js

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

package/src/tryExecuteFunction.js

@@ -10,18 +10,16 @@ const { PROTO_ACTION_TYPES } = require("./consts");
 // tryExecuteFunction will create a new database transaction around a function call
 // and handle any permissions checks. If a permission check fails, then an Error will be thrown and the catch block will be hit.
 function tryExecuteFunction(
-  { db, permitted, permissionFns, actionTypes, request, ctx },
+  { db, permitted, permissionFns, actionType, request, ctx },
   cb
 ) {
-  const actionType = actionTypes[request.method];
-
   return withPermissions(permitted, async ({ getPermissionState }) => {
     return withDatabase(db, actionType, async ({ transaction }) => {
       const fnResult = await cb();
-
       // 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.
+
       switch (getPermissionState()) {
         case PERMISSION_STATE.PERMITTED:
           return fnResult;