@teamkeel/functions-runtime 0.338.0 → 0.339.0

package/src/ModelAPI.test.js

@@ -4,9 +4,6 @@ const { sql } = require("kysely");
 const { useDatabase } = require("./database");
 const KSUID = require("ksuid");
 
-process.env.KEEL_DB_CONN_TYPE = "pg";
-process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
-
 let personAPI;
 let postAPI;
 let authorAPI;

package/src/database.js

@@ -1,4 +1,4 @@
-const { Kysely, PostgresDialect } = require("kysely");
+const { Kysely, PostgresDialect, CamelCasePlugin } = require("kysely");
 const { AsyncLocalStorage } = require("async_hooks");
 const pg = require("pg");
 const { PROTO_ACTION_TYPES } = require("./consts");
@@ -35,24 +35,51 @@ async function withDatabase(db, actionType, cb) {
 }
 
 let db = null;
+
 const dbInstance = new AsyncLocalStorage();
 
 // useDatabase will retrieve the database client set by withDatabase from the local storage
 function useDatabase() {
+  // retrieve the instance of the database client from the store which is aware of
+  // which context the current connection to the db is running in - e.g does the context
+  // require a transaction or not?
   let fromStore = dbInstance.getStore();
   if (fromStore) {
     return fromStore;
   }
 
+  // if the NODE_ENV is 'test' then we know we are inside of the vitest environment
+  // which covers any test files ending in *.test.ts. Custom function code runs in a different node process which will not have this environment variable. Tests written using our testing
+  // framework call actions (and in turn custom function code) over http using the ActionExecutor class
+  if ("NODE_ENV" in process.env && process.env.NODE_ENV == "test") {
+    return getDatabaseClient();
+  }
+
+  // If we've gotten to this point, then we know that we are in a custom function runtime server
+  // context and we haven't been able to retrieve the in-context instance of Kysely, which means we should throw an error.
+  throw new Error("useDatabase must be called within a function");
+}
+
+// getDatabaseClient will return a brand new instance of Kysely. Every instance of Kysely
+// represents an individual connection to the database.
+// not to be exported externally from our sdk - consumers should use useDatabase
+function getDatabaseClient() {
+  // 'db' represents the singleton connection to the database which is stored
+  // as a module scope variable.
   if (db) {
     return db;
   }
 
-  // todo: ideally we wouldn't want to give you a fresh Kysely instance here if nothing
-  // has been found in the context, but the @teamkeel/testing package needs some restructuring
-  // to allow for the database client to be set in the store so that this method can throw an error at this line instead of returning a fresh kysely instance.
   db = new Kysely({
     dialect: getDialect(),
+    plugins: [
+      // allows users to query using camelCased versions of the database column names, which
+      // should match the names we use in our schema.
+      // https://kysely-org.github.io/kysely/classes/CamelCasePlugin.html
+      // If they don't, then we can create a custom implementation of the plugin where we control
+      // the casing behaviour (see url above for example)
+      new CamelCasePlugin(),
+    ],
     log(event) {
       if ("DEBUG" in process.env) {
         if (event.level === "query") {
@@ -66,14 +93,6 @@ function useDatabase() {
   return db;
 }
 
-function mustEnv(key) {
-  const v = process.env[key];
-  if (!v) {
-    throw new Error(`expected environment variable ${key} to be set`);
-  }
-  return v;
-}
-
 class InstrumentedPool extends pg.Pool {
   async connect(...args) {
     const _super = super.connect.bind(this);
@@ -127,5 +146,17 @@ function getDialect() {
   }
 }
 
+function mustEnv(key) {
+  const v = process.env[key];
+  if (!v) {
+    throw new Error(`expected environment variable ${key} to be set`);
+  }
+  return v;
+}
+
+// initialise the database client at module scope level so the db variable is set
+getDatabaseClient();
+
+module.exports.getDatabaseClient = getDatabaseClient;
 module.exports.useDatabase = useDatabase;
 module.exports.withDatabase = withDatabase;

package/src/handleRequest.js

@@ -3,7 +3,7 @@ const {
   createJSONRPCSuccessResponse,
   JSONRPCErrorCode,
 } = require("json-rpc-2.0");
-const { useDatabase } = require("./database");
+const { getDatabaseClient } = require("./database");
 const { tryExecuteFunction } = require("./tryExecuteFunction");
 const { errorToJSONRPCResponse, RuntimeErrors } = require("./errors");
 const opentelemetry = require("@opentelemetry/api");
@@ -57,7 +57,7 @@ async function handleRequest(request, config) {
             ? true
             : null;
 
-        const db = useDatabase();
+        const db = getDatabaseClient();
         const customFunction = functions[request.method];
 
         const result = await tryExecuteFunction(

package/src/handleRequest.test.js

@@ -8,9 +8,6 @@ const { Permissions } = require("./permissions");
 import { PROTO_ACTION_TYPES } from "./consts";
 import KSUID from "ksuid";
 
-process.env.KEEL_DB_CONN_TYPE = "pg";
-process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
-
 test("when the custom function returns expected value", async () => {
   const config = {
     functions: {

package/src/permissions.test.js

@@ -10,9 +10,6 @@ import { useDatabase } from "./database";
 
 import { beforeEach, describe, expect, test } from "vitest";
 
-process.env.KEEL_DB_CONN_TYPE = "pg";
-process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
-
 let permissions;
 let ctx = {};
 let db = useDatabase();

package/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig, loadEnv } from "vite";
+
+export default ({ mode }) => {
+  process.env = { ...process.env, ...loadEnv(mode, process.cwd(), "") };
+
+  return defineConfig({});
+};