@teamkeel/functions-runtime 0.412.0-next.3 → 0.412.0

package/src/handleJob.test.js

@@ -0,0 +1,270 @@
+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";
+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 () => {
+    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: "",
+      },
+    });
+  });
+
+  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" of relation "post" violates not-null constraint',
+        data: {
+          code: "23502",
+          column: "title",
+          detail: expect.stringContaining("Failing row contains"),
+          table: "post",
+          value: undefined,
+        },
+      },
+    });
+  });
+
+  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" of relation "post" violates not-null constraint',
+        data: {
+          code: "23502",
+          column: "author_id",
+          detail: expect.stringContaining("Failing row contains"),
+          table: "post",
+          value: undefined,
+        },
+      },
+    });
+  });
+
+  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

@@ -0,0 +1,153 @@
+const {
+  createJSONRPCErrorResponse,
+  createJSONRPCSuccessResponse,
+  JSONRPCErrorCode,
+} = require("json-rpc-2.0");
+const { createDatabaseClient } = require("./database");
+const { tryExecuteFunction } = require("./tryExecuteFunction");
+const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
+const opentelemetry = require("@opentelemetry/api");
+const { withSpan } = require("./tracing");
+const { parseInputs, parseOutputs } = require("./parsing");
+
+// Generic handler function that is agnostic to runtime environment (local or lambda)
+// to execute a custom 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 handleRequest(request, config) {
+  // Try to extract trace context from caller
+  const activeContext = opentelemetry.propagation.extract(
+    opentelemetry.context.active(),
+    request.meta?.tracing
+  );
+
+  if (process.env.KEEL_LOG_LEVEL == "debug") {
+    console.log(request);
+  }
+
+  // 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) => {
+      let db = null;
+
+      try {
+        const { createContextAPI, functions, permissionFns, actionTypes } =
+          config;
+
+        if (!(request.method in functions)) {
+          const message = `no corresponding function found for '${request.method}'`;
+          span.setStatus({
+            code: opentelemetry.SpanStatusCode.ERROR,
+            message: message,
+          });
+          return createJSONRPCErrorResponse(
+            request.id,
+            JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+
+        // headers reference passed to custom function where object data can be modified
+        const headers = new Headers();
+
+        // The ctx argument passed into the custom function.
+        const ctx = createContextAPI({
+          responseHeaders: headers,
+          meta: request.meta,
+        });
+
+        // The Go runtime does *some* permissions checks up front before the request reaches
+        // this method, so we pass in a permissionState object on the request.meta object that
+        // indicates whether a call to a custom function has already been authorised
+        const permitted =
+          request.meta && request.meta.permissionState.status === "granted"
+            ? true
+            : null;
+
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN,
+        });
+        const customFunction = functions[request.method];
+        const actionType = actionTypes[request.method];
+
+        const functionConfig = customFunction?.config ?? {};
+
+        const result = await tryExecuteFunction(
+          {
+            request,
+            ctx,
+            permitted,
+            db,
+            permissionFns,
+            actionType,
+            functionConfig,
+          },
+          async () => {
+            // parse request params to convert objects into rich field types (e.g. InlineFile)
+            const inputs = parseInputs(request.params);
+
+            // 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
+            // the transaction to the db. If a permission rule is violated, any changes made inside the transaction are rolled back.
+            const result = await customFunction(ctx, inputs);
+
+            return parseOutputs(result);
+          }
+        );
+
+        if (result instanceof Error) {
+          span.recordException(result);
+          span.setStatus({
+            code: opentelemetry.SpanStatusCode.ERROR,
+            message: result.message,
+          });
+          return errorToJSONRPCResponse(request, result);
+        }
+
+        const response = createJSONRPCSuccessResponse(request.id, result);
+
+        const responseHeaders = {};
+        for (const pair of headers.entries()) {
+          responseHeaders[pair[0]] = pair[1].split(", ");
+        }
+        response.meta = {
+          headers: responseHeaders,
+          status: ctx.response.status,
+        };
+
+        return response;
+      } 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
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+
+module.exports = {
+  handleRequest,
+  RuntimeErrors,
+};