@teamkeel/functions-runtime 0.411.0 → 0.412.0-next.1

package/src/handleRequest.test.js

@@ -1,463 +0,0 @@
-import { createJSONRPCRequest, JSONRPCErrorCode } from "json-rpc-2.0";
-import { sql } from "kysely";
-import { handleRequest, RuntimeErrors } from "./handleRequest";
-import { test, expect, beforeEach, describe } from "vitest";
-import { ModelAPI } from "./ModelAPI";
-import { useDatabase } from "./database";
-const { Permissions } = require("./permissions");
-import { PROTO_ACTION_TYPES } from "./consts";
-import KSUID from "ksuid";
-import { ErrorPresets } from "./errors";
-
-test("when the custom function returns expected value", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {
-        new Permissions().allow();
-
-        return {
-          title: "a post",
-          id: "abcde",
-        };
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    meta: {
-      headers: {},
-    },
-    result: {
-      title: "a post",
-      id: "abcde",
-    },
-  });
-});
-
-test("when there is no matching function for the path", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {},
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "unknown", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    error: {
-      code: JSONRPCErrorCode.MethodNotFound,
-      message: "no corresponding function found for 'unknown'",
-    },
-  });
-});
-
-test("when there is an unexpected error in the custom function", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {
-        throw new Error("oopsie daisy");
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    error: {
-      code: RuntimeErrors.UnknownError,
-      message: "oopsie daisy",
-    },
-  });
-});
-
-test("when a role based permission has already been granted by the main runtime", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs, api) => {
-        return {
-          title: inputs.title,
-        };
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createModelAPI: () => {},
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  let rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  Object.assign(rpcReq, {
-    ...rpcReq,
-    meta: { permissionState: { status: "granted", reason: "role" } },
-  });
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    result: {
-      title: "a post",
-    },
-    meta: {
-      headers: {},
-    },
-  });
-});
-
-test("when there is an unexpected object thrown in the custom function", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {
-        throw { err: "oopsie daisy" };
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    error: {
-      code: RuntimeErrors.UnknownError,
-      message: '{"err":"oopsie daisy"}',
-    },
-  });
-});
-
-test("when a NotFound error preset is thrown in the custom function", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {
-        throw new ErrorPresets.NotFound("not here");
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    error: {
-      code: RuntimeErrors.RecordNotFoundError,
-      message: "not here",
-    },
-  });
-});
-
-test("when a NotFound error preset is returned in the custom function", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {
-        new Permissions().allow();
-        return new ErrorPresets.NotFound("not here");
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    error: {
-      code: RuntimeErrors.RecordNotFoundError,
-      message: "not here",
-    },
-  });
-});
-
-test("when a BadRequest error preset is thrown in the custom function", async () => {
-  const config = {
-    functions: {
-      createPost: async (ctx, inputs) => {
-        throw new ErrorPresets.BadRequest("invalid inputs");
-      },
-    },
-    actionTypes: {
-      createPost: PROTO_ACTION_TYPES.CREATE,
-    },
-    createContextAPI: () => {
-      return {
-        response: {
-          headers: new Headers(),
-        },
-      };
-    },
-  };
-
-  const rpcReq = createJSONRPCRequest("123", "createPost", { title: "a post" });
-
-  expect(await handleRequest(rpcReq, config)).toEqual({
-    id: "123",
-    jsonrpc: "2.0",
-    error: {
-      code: RuntimeErrors.BadRequestError,
-      message: "invalid inputs",
-    },
-  });
-});
-
-// 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 () => {
-    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 ('adam', 'adam bull')
-    `.execute(db);
-
-    const models = {
-      post: new ModelAPI("post", undefined, {
-        post: {
-          author: {
-            relationshipType: "belongsTo",
-            foreignKey: "author_id",
-            referencesTable: "person",
-          },
-        },
-      }),
-    };
-
-    functionConfig = {
-      permissionFns: {},
-      actionTypes: {
-        createPost: PROTO_ACTION_TYPES.CREATE,
-        deletePost: PROTO_ACTION_TYPES.DELETE,
-      },
-      functions: {
-        createPost: async (ctx, inputs) => {
-          new Permissions().allow();
-
-          const post = await models.post.create({
-            id: KSUID.randomSync().string,
-            ...inputs,
-          });
-
-          return post;
-        },
-        deletePost: async (ctx, inputs) => {
-          new Permissions().allow();
-
-          const deleted = await models.post.delete(inputs);
-
-          return deleted;
-        },
-      },
-      createContextAPI: () => {
-        return {
-          response: {
-            headers: new Headers(),
-          },
-        };
-      },
-    };
-  });
-
-  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: "",
-      },
-    });
-  });
-
-  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" 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', '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" 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 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",
-        },
-      },
-    });
-  });
-});

package/src/handleRoute.js

@@ -1,112 +0,0 @@
-const {
-  createJSONRPCErrorResponse,
-  createJSONRPCSuccessResponse,
-  JSONRPCErrorCode,
-} = require("json-rpc-2.0");
-const { createDatabaseClient, withDatabase } = require("./database");
-const { withAuditContext } = require("./auditing");
-const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
-const opentelemetry = require("@opentelemetry/api");
-const { withSpan } = require("./tracing");
-
-async function handleRoute(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) => {
-      let db = null;
-
-      try {
-        const { createContextAPI, functions } = config;
-
-        if (!(request.method in functions)) {
-          const message = `no route function found for '${request.method}'`;
-          span.setStatus({
-            code: opentelemetry.SpanStatusCode.ERROR,
-            message: message,
-          });
-          return createJSONRPCErrorResponse(
-            request.id,
-            JSONRPCErrorCode.MethodNotFound,
-            message
-          );
-        }
-
-        // For route functions context doesn't need request headers or the response object as this is handled by
-        // params and the function response respectively
-        const {
-          headers,
-          response: __,
-          ...ctx
-        } = createContextAPI({
-          responseHeaders: new Headers(),
-          meta: request.meta,
-        });
-
-        // Add request headers to params
-        request.params.headers = headers;
-
-        db = createDatabaseClient({
-          connString: request.meta?.secrets?.KEEL_DB_CONN,
-        });
-        const routeHandler = functions[request.method];
-
-        const result = await withDatabase(db, false, () => {
-          return withAuditContext(request, () => {
-            return routeHandler(request.params, ctx);
-          });
-        });
-
-        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);
-
-        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 = {
-  handleRoute,
-  RuntimeErrors,
-};

package/src/handleSubscriber.js

@@ -1,105 +0,0 @@
-const {
-  createJSONRPCErrorResponse,
-  createJSONRPCSuccessResponse,
-  JSONRPCErrorCode,
-} = require("json-rpc-2.0");
-const { createDatabaseClient } = 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");
-const { parseInputs } = require("./parsing");
-
-// 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) => {
-      let db = null;
-
-      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,
-        });
-
-        db = createDatabaseClient({
-          connString: request.meta?.secrets?.KEEL_DB_CONN,
-        });
-        const subscriberFunction = subscribers[request.method];
-        const actionType = PROTO_ACTION_TYPES.SUBSCRIBER;
-
-        const functionConfig = subscriberFunction?.config ?? {};
-
-        await tryExecuteSubscriber(
-          { request, db, actionType, functionConfig },
-          async () => {
-            // parse request params to convert objects into rich field types (e.g. InlineFile)
-            const inputs = parseInputs(request.params);
-
-            // Return the subscriber function to the containing tryExecuteSubscriber block
-            return subscriberFunction(ctx, inputs);
-          }
-        );
-
-        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
-        );
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-
-module.exports = {
-  handleSubscriber,
-  RuntimeErrors,
-};