@teamkeel/functions-runtime 0.247.3 → 0.248.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.247.3",
+  "version": "0.248.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
-    "test": "vitest run --reporter verbose",
+    "test": "vitest run --reporter verbose --threads false",
     "format": "npx prettier --write src/**/*.js"
   },
   "keywords": [],

package/src/ModelAPI.js

@@ -47,11 +47,12 @@ class ModelAPI {
 
   async create(values) {
     try {
+      const defaults = this._defaultValues();
       const row = await this._db
         .insertInto(this._tableName)
         .values(
           snakeCaseObject({
-            ...this._defaultValues(),
+            ...defaults,
             ...values,
           })
         )

package/src/ModelAPI.test.js

@@ -1,5 +1,5 @@
 import { test, expect, beforeEach } from "vitest";
-const { ModelAPI } = require("./ModelAPI");
+const { ModelAPI, DatabaseError } = require("./ModelAPI");
 const { sql } = require("kysely");
 const { getDatabase } = require("./database");
 const KSUID = require("ksuid");
@@ -9,6 +9,7 @@ process.env.DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-r
 
 let personAPI;
 let postAPI;
+let authorAPI;
 
 beforeEach(async () => {
   const db = getDatabase();
@@ -16,6 +17,8 @@ beforeEach(async () => {
   await sql`
   DROP TABLE IF EXISTS post;
   DROP TABLE IF EXISTS person;
+  DROP TABLE IF EXISTS author;
+
   CREATE TABLE person(
       id               text PRIMARY KEY,
       name             text UNIQUE,
@@ -27,7 +30,11 @@ beforeEach(async () => {
     id               text PRIMARY KEY,
     title            text,
     author_id        text references person(id)
-);
+  );
+  CREATE TABLE author(
+    id               text PRIMARY KEY,
+    name             text NOT NULL
+  );
   `.execute(db);
 
   const tableConfigMap = {
@@ -69,6 +76,17 @@ beforeEach(async () => {
     db,
     tableConfigMap
   );
+
+  authorAPI = new ModelAPI(
+    "author",
+    () => {
+      return {
+        id: KSUID.randomSync().string,
+      };
+    },
+    db,
+    tableConfigMap
+  );
 });
 
 test("ModelAPI.create", async () => {
@@ -84,6 +102,14 @@ test("ModelAPI.create", async () => {
   expect(KSUID.parse(row.id).string).toEqual(row.id);
 });
 
+test("ModelAPI.create - throws if not not null constraint violation", async () => {
+  await expect(
+    authorAPI.create({
+      name: null,
+    })
+  ).rejects.toThrow('null value in column "name" violates not-null constraint');
+});
+
 test("ModelAPI.create - throws if database constraint fails", async () => {
   const row = await personAPI.create({
     name: "Jim",
@@ -590,6 +616,25 @@ test("ModelAPI.update - throws if not found", async () => {
   await expect(result).rejects.toThrow("no result");
 });
 
+test("ModelAPI.update - throws if not not null constraint violation", async () => {
+  const jim = await authorAPI.create({
+    name: "jim",
+  });
+
+  const result = authorAPI.update(
+    {
+      id: jim.id,
+    },
+    {
+      name: null,
+    }
+  );
+
+  await expect(result).rejects.toThrow(
+    'null value in column "name" violates not-null constraint'
+  );
+});
+
 test("ModelAPI.delete", async () => {
   const jim = await personAPI.create({
     name: "Jim",

package/src/errors.js

@@ -1,19 +1,83 @@
-const { DatabaseError } = require("./ModelAPI");
 const { createJSONRPCErrorResponse } = require("json-rpc-2.0");
 
 const RuntimeErrors = {
+  // Catchall error type for unhandled execution errors during custom function
   UnknownError: -32001,
+  // DatabaseError represents any error at pg level that isn't handled explicitly below
   DatabaseError: -32002,
+  // No result returned from custom function by user
+  NoResultError: -32003,
+  // When trying to delete/update a non existent record in the db
+  RecordNotFoundError: -32004,
+  ForeignKeyConstraintError: -32005,
+  NotNullConstraintError: -32006,
+  UniqueConstraintError: -32007,
 };
 
-// transforms a JavaScript Error instance (or derivative) into a valid JSONRPC response object
-// to pass back to the Keel runtime
+// errorToJSONRPCResponse transforms a JavaScript Error instance (or derivative) into a valid JSONRPC response object to pass back to the Keel runtime.
 function errorToJSONRPCResponse(request, e) {
+  if (!e.error) {
+    return createJSONRPCErrorResponse(
+      request.id,
+      RuntimeErrors.UnknownError,
+      e.message
+    );
+  }
   // we want to switch on instanceof but there is no way to do that in js, so best to check the constructor class of the error
 
   // todo: fuzzy matching on postgres errors from both rds-data-api and pg-protocol
-  switch (e.constructor) {
-    case DatabaseError:
+
+  switch (e.error.constructor.name) {
+    // Any error thrown in the ModelAPI class is
+    // wrapped in a DatabaseError in order to differentiate 'our code' vs the user's own code.
+    case "NoResultError":
+      return createJSONRPCErrorResponse(
+        request.id,
+
+        // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
+        RuntimeErrors.RecordNotFoundError,
+        e.message
+      );
+    case "DatabaseError":
+      const { error: originalError } = e;
+
+      // if the originalError responds to 'code' then assume it has other pg error message keys
+      // todo: make this more ironclad.
+      // when using lib-pq, should match https://github.com/brianc/node-postgres/blob/master/packages/pg-protocol/src/parser.ts#L371-L386
+      if ("code" in originalError) {
+        const { code, detail, table } = originalError;
+
+        let rpcErrorCode, column, value;
+        const [col, val] = parseKeyMessage(originalError.detail);
+        column = col;
+        value = val;
+
+        switch (code) {
+          case "23502":
+            rpcErrorCode = RuntimeErrors.NotNullConstraintError;
+            column = originalError.column;
+            break;
+          case "23503":
+            rpcErrorCode = RuntimeErrors.ForeignKeyConstraintError;
+            break;
+          case "23505":
+            rpcErrorCode = RuntimeErrors.UniqueConstraintError;
+            break;
+          default:
+            rpcErrorCode = RuntimeErrors.DatabaseError;
+            break;
+        }
+
+        return createJSONRPCErrorResponse(request.id, rpcErrorCode, e.message, {
+          table,
+          column,
+          code,
+          detail,
+          value,
+        });
+      }
+
+      // we don't know what it is, but it's something else
       return createJSONRPCErrorResponse(
         request.id,
         RuntimeErrors.DatabaseError,
@@ -28,6 +92,15 @@ function errorToJSONRPCResponse(request, e) {
   }
 }
 
+// example data:
+// Key (author_id)=(fake) is not present in table "author".
+const keyMessagePattern = /\Key\s[(](.*)[)][=][(](.*)[)]/;
+const parseKeyMessage = (msg) => {
+  const [, col, value] = keyMessagePattern.exec(msg) || [];
+
+  return [col, value];
+};
+
 module.exports = {
   errorToJSONRPCResponse,
   RuntimeErrors,

package/src/handleRequest.js

@@ -31,7 +31,7 @@ async function handleRequest(request, config) {
       // no result returned from custom function
       return createJSONRPCErrorResponse(
         request.id,
-        JSONRPCErrorCode.InternalError,
+        RuntimeErrors.NoResultError,
         `no result returned from function '${request.method}'`
       );
     }

package/src/handleRequest.test.js

@@ -1,6 +1,10 @@
 import { createJSONRPCRequest, JSONRPCErrorCode } from "json-rpc-2.0";
+import { sql } from "kysely";
 import { handleRequest, RuntimeErrors } from "./handleRequest";
-import { test, expect } from "vitest";
+import { test, expect, beforeEach, describe } from "vitest";
+import { ModelAPI } from "./ModelAPI";
+import { getDatabase } from "./database";
+import KSUID from "ksuid";
 
 test("when the custom function returns expected value", async () => {
   const config = {
@@ -43,7 +47,7 @@ test("when the custom function doesnt return a value", async () => {
     id: "123",
     jsonrpc: "2.0",
     error: {
-      code: JSONRPCErrorCode.InternalError,
+      code: RuntimeErrors.NoResultError,
       message: "no result returned from function 'createPost'",
     },
   });
@@ -115,3 +119,186 @@ test("when there is an unexpected object thrown in the custom function", async (
     },
   });
 });
+
+// The following tests assert on the various
+// jsonrpc responses that *should* happen when a user
+// writes a custom function 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.DB_CONN_TYPE = "pg";
+    process.env.DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
+
+    db = getDatabase();
+
+    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 ('adam', 'adam bull')
+    `.execute(db);
+
+    functionConfig = {
+      functions: {
+        createPost: async (inputs, api, ctx) => {
+          const post = await api.models.post.create(inputs);
+
+          return post;
+        },
+        deletePost: async (inputs, api, ctx) => {
+          const deleted = await api.models.post.delete(inputs);
+
+          return deleted;
+        },
+      },
+      createFunctionAPI: () => ({
+        models: {
+          post: new ModelAPI(
+            "post",
+            () => {
+              return {
+                id: KSUID.randomSync().string,
+              };
+            },
+            db,
+            {
+              post: {
+                author: {
+                  relationshipType: "belongsTo",
+                  foreignKey: "author_id",
+                  referencesTable: "person",
+                },
+              },
+            }
+          ),
+        },
+      }),
+      createContextAPI: () => ({}),
+    };
+  });
+
+  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",
+    });
+
+    expect(await handleRequest(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 });
+
+    expect(await handleRequest(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', 'adam')
+    `.execute(db);
+
+    const rpcReq = createJSONRPCRequest("123", "createPost", {
+      title: "hello",
+      author_id: "something",
+    });
+
+    expect(await handleRequest(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" });
+
+    expect(await handleRequest(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 rpcReq2 = createJSONRPCRequest("123", "createPost", {
+      title: "123",
+      author_id: "fake",
+    });
+
+    expect(await handleRequest(rpcReq2, 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",
+        },
+      },
+    });
+  });
+});