@teamkeel/functions-runtime 0.395.14 → 0.396.0

package/package.json

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

package/src/auditing.test.js

@@ -65,23 +65,19 @@ test("auditing - capturing identity id in transaction", async () => {
 
   const identityId = request.meta.identity.id;
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.CREATE, // CREATE will ensure a transaction is opened
-    async ({ transaction }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.create({
-          id: KSUID.randomSync().string,
-          name: "James",
-        });
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "James",
       });
+    });
 
-      expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
-      expect(await identityIdFromConfigParam(db)).toBeNull();
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await identityIdFromConfigParam(db)).toBeNull();
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("James");
   expect(await identityIdFromConfigParam(db)).toBeNull();
@@ -101,23 +97,19 @@ test("auditing - capturing tracing in transaction", async () => {
     request.meta.tracing.traceparent
   ).traceId;
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.CREATE, // CREATE will ensure a transaction is opened
-    async ({ transaction }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.create({
-          id: KSUID.randomSync().string,
-          name: "Jim",
-        });
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jim",
       });
+    });
 
-      expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
-      expect(await traceIdFromConfigParam(db)).toBeNull();
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+    expect(await traceIdFromConfigParam(db)).toBeNull();
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("Jim");
   expect(await traceIdFromConfigParam(db)).toBeNull();
@@ -131,23 +123,19 @@ test("auditing - capturing identity id without transaction", async () => {
     },
   };
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.GET, // GET will _not_ open a transaction
-    async ({ sDb }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.create({
-          id: KSUID.randomSync().string,
-          name: "James",
-        });
+  const row = await withDatabase(db, false, async ({ sDb }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "James",
       });
+    });
 
-      expect(await identityIdFromConfigParam(sDb)).toBeNull();
-      expect(await identityIdFromConfigParam(db)).toBeNull();
+    expect(await identityIdFromConfigParam(sDb)).toBeNull();
+    expect(await identityIdFromConfigParam(db)).toBeNull();
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("James");
   expect(await identityIdFromConfigParam(db)).toBeNull();
@@ -163,23 +151,19 @@ test("auditing - capturing tracing without transaction", async () => {
     },
   };
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.GET, // GET will _not_ open a transaction
-    async ({ sDb }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.create({
-          id: KSUID.randomSync().string,
-          name: "Jim",
-        });
+  const row = await withDatabase(db, false, async ({ sDb }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jim",
       });
+    });
 
-      expect(await traceIdFromConfigParam(sDb)).toBeNull();
-      expect(await traceIdFromConfigParam(db)).toBeNull();
+    expect(await traceIdFromConfigParam(sDb)).toBeNull();
+    expect(await traceIdFromConfigParam(db)).toBeNull();
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("Jim");
   expect(await traceIdFromConfigParam(db)).toBeNull();
@@ -225,23 +209,19 @@ test("auditing - ModelAPI.create", async () => {
     request.meta.tracing.traceparent
   ).traceId;
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.CREATE,
-    async ({ transaction }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.create({
-          id: KSUID.randomSync().string,
-          name: "Jake",
-        });
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jake",
       });
+    });
 
-      expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
-      expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("Jake");
 });
@@ -266,20 +246,16 @@ test("auditing - ModelAPI.update", async () => {
     name: "Jake",
   });
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.CREATE,
-    async ({ transaction }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.update({ id: created.id }, { name: "Jim" });
-      });
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.update({ id: created.id }, { name: "Jim" });
+    });
 
-      expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
-      expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("Jim");
 });
@@ -304,20 +280,16 @@ test("auditing - ModelAPI.delete", async () => {
     name: "Jake",
   });
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.CREATE,
-    async ({ transaction }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.delete({ id: created.id });
-      });
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.delete({ id: created.id });
+    });
 
-      expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
-      expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row).toEqual(created.id);
 });
@@ -337,23 +309,19 @@ test("auditing - identity id and trace id fields dropped from result", async ()
     request.meta.tracing.traceparent
   ).traceId;
 
-  const row = await withDatabase(
-    db,
-    PROTO_ACTION_TYPES.CREATE,
-    async ({ transaction }) => {
-      const row = withAuditContext(request, async () => {
-        return await personAPI.create({
-          id: KSUID.randomSync().string,
-          name: "Jake",
-        });
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jake",
       });
+    });
 
-      expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
-      expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
 
-      return row;
-    }
-  );
+    return row;
+  });
 
   expect(row.name).toEqual("Jake");
   expect(row.keelIdentityId).toBeUndefined();

package/src/database.js

@@ -14,18 +14,7 @@ const ws = require("ws");
 // the user's custom function is wrapped in a transaction so we can rollback
 // the transaction if something goes wrong.
 // withDatabase shouldn't be exposed in the public api of the sdk
-async function withDatabase(db, actionType, cb) {
-  let requiresTransaction = true;
-
-  switch (actionType) {
-    case PROTO_ACTION_TYPES.SUBSCRIBER:
-    case PROTO_ACTION_TYPES.JOB:
-    case PROTO_ACTION_TYPES.GET:
-    case PROTO_ACTION_TYPES.LIST:
-      requiresTransaction = false;
-      break;
-  }
-
+async function withDatabase(db, requiresTransaction, cb) {
   // db.transaction() provides a kysely instance bound to a transaction.
   if (requiresTransaction) {
     return db.transaction().execute(async (transaction) => {
@@ -185,6 +174,7 @@ function getDialect() {
 
       const pool = new InstrumentedNeonServerlessPool({
         connectionString: mustEnv("KEEL_DB_CONN"),
+        max: 1, // Limit to 1 connection per Lambda instance
       });
 
       pool.on("connect", (client) => {

package/src/handleJob.js

@@ -57,8 +57,10 @@ async function handleJob(request, config) {
         const jobFunction = jobs[request.method];
         const actionType = PROTO_ACTION_TYPES.JOB;
 
+        const functionConfig = jobFunction?.config ?? {};
+
         await tryExecuteJob(
-          { request, permitted, db, actionType },
+          { request, permitted, db, actionType, functionConfig },
           async () => {
             // parse request params to convert objects into rich field types (e.g. InlineFile)
             const inputs = parseInputs(request.params);

package/src/handleRequest.js

@@ -68,8 +68,18 @@ async function handleRequest(request, config) {
         const customFunction = functions[request.method];
         const actionType = actionTypes[request.method];
 
+        const functionConfig = customFunction?.config ?? {};
+
         const result = await tryExecuteFunction(
-          { request, ctx, permitted, db, permissionFns, actionType },
+          {
+            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);

package/src/handleSubscriber.js

@@ -52,13 +52,18 @@ async function handleSubscriber(request, config) {
         const subscriberFunction = subscribers[request.method];
         const actionType = PROTO_ACTION_TYPES.SUBSCRIBER;
 
-        await tryExecuteSubscriber({ request, db, actionType }, async () => {
-          // parse request params to convert objects into rich field types (e.g. InlineFile)
-          const inputs = parseInputs(request.params);
+        const functionConfig = subscriberFunction?.config ?? {};
 
-          // Return the subscriber function to the containing tryExecuteSubscriber block
-          return subscriberFunction(ctx, inputs);
-        });
+        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) {

package/src/index.d.ts

@@ -227,3 +227,15 @@ export type Errors = {
    */
   Unknown: typeof UnknownError;
 };
+
+export type FunctionConfig = {
+  /**
+   * All DB calls within the function will be executed within a transaction.
+   * The transaction is rolled back if the function throws an error.
+   */
+  dbTransaction?: boolean;
+};
+
+export type FuncWithConfig<T> = T & {
+  config: FunctionConfig;
+};

package/src/tryExecuteFunction.js

@@ -11,11 +11,24 @@ 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(
-  { request, db, permitted, permissionFns, actionType, ctx },
+  { request, db, permitted, permissionFns, actionType, ctx, functionConfig },
   cb
 ) {
   return withPermissions(permitted, async ({ getPermissionState }) => {
-    return withDatabase(db, actionType, async ({ transaction }) => {
+    let requiresTransaction = true;
+    switch (actionType) {
+      case PROTO_ACTION_TYPES.GET:
+      case PROTO_ACTION_TYPES.LIST:
+      case PROTO_ACTION_TYPES.READ:
+        requiresTransaction = false;
+        break;
+    }
+
+    if (functionConfig?.dbTransaction !== undefined) {
+      requiresTransaction = functionConfig.dbTransaction;
+    }
+
+    return withDatabase(db, requiresTransaction, async ({ transaction }) => {
       const fnResult = await withAuditContext(request, async () => {
         return cb();
       });

package/src/tryExecuteJob.js

@@ -5,9 +5,13 @@ const { PermissionError } = require("./errors");
 
 // tryExecuteJob 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 tryExecuteJob({ db, permitted, actionType, request }, cb) {
+function tryExecuteJob({ db, permitted, request, functionConfig }, cb) {
   return withPermissions(permitted, async ({ getPermissionState }) => {
-    return withDatabase(db, actionType, async () => {
+    let requiresTransaction = true;
+    if (functionConfig?.dbTransaction !== undefined) {
+      requiresTransaction = functionConfig.dbTransaction;
+    }
+    return withDatabase(db, requiresTransaction, async () => {
       await withAuditContext(request, async () => {
         return cb();
       });

package/src/tryExecuteSubscriber.js

@@ -2,8 +2,12 @@ const { withDatabase } = require("./database");
 const { withAuditContext } = require("./auditing");
 
 // tryExecuteSubscriber will create a new database connection and execute the function call.
-function tryExecuteSubscriber({ request, db, actionType }, cb) {
-  return withDatabase(db, actionType, async () => {
+function tryExecuteSubscriber({ request, db, functionConfig }, cb) {
+  let requiresTransaction = true;
+  if (functionConfig?.dbTransaction !== undefined) {
+    requiresTransaction = functionConfig.dbTransaction;
+  }
+  return withDatabase(db, requiresTransaction, async () => {
     await withAuditContext(request, async () => {
       return cb();
     });