@teamkeel/functions-runtime 0.394.2 → 0.395.0-next.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.394.2",
+  "version": "0.395.0-next.1",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
@@ -21,6 +21,7 @@
   "dependencies": {
     "@aws-sdk/client-s3": "^3.637.0",
     "@aws-sdk/credential-providers": "^3.637.0",
+    "@aws-sdk/s3-request-presigner": "^3.637.0",
     "@neondatabase/serverless": "^0.9.4",
     "@opentelemetry/api": "^1.7.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.46.0",

package/src/File.js

@@ -4,7 +4,8 @@ const {
   GetObjectCommand,
 } = require("@aws-sdk/client-s3");
 const { fromEnv } = require("@aws-sdk/credential-providers");
-const { useDatabase } = require("./database");
+const { getSignedUrl } = require("@aws-sdk/s3-request-presigner");
+const { createDatabaseClient } = require("./database");
 const { DatabaseError } = require("./errors");
 const KSUID = require("ksuid");
 
@@ -105,9 +106,7 @@ class File extends InlineFile {
   async read() {
     if (this._contents) {
       const arrayBuffer = await this._contents.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      return buffer;
+      return Buffer.from(arrayBuffer);
     }
 
     if (isS3Storage()) {
@@ -122,12 +121,12 @@ class File extends InlineFile {
       };
       const command = new GetObjectCommand(params);
       const response = await s3Client.send(command);
-      const blob = response.Body.transformToByteArray();
+      const blob = await response.Body.transformToByteArray();
       return Buffer.from(blob);
     }
 
     // default to db storage
-    const db = useDatabase();
+    const db = createDatabaseClient();
 
     try {
       let query = db
@@ -139,6 +138,8 @@ class File extends InlineFile {
       return row.data;
     } catch (e) {
       throw new DatabaseError(e);
+    } finally {
+      await db.destroy();
     }
   }
 
@@ -157,12 +158,39 @@ class File extends InlineFile {
     return this;
   }
 
+  async getPresignedUrl() {
+    if (isS3Storage()) {
+      const s3Client = new S3Client({
+        credentials: fromEnv(),
+        region: process.env.KEEL_REGION,
+      });
+
+      const command = new GetObjectCommand({
+        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+        Key: "files/" + this.key,
+        ResponseContentDisposition: `attachment; filename="${encodeURIComponent(
+          this.filename
+        )}"`,
+      });
+
+      const url = await getSignedUrl(s3Client, command, { expiresIn: 60 * 60 });
+
+      return new URL(url);
+    } else {
+      const contents = await this.read();
+      const dataurl = `data:${this.contentType};name=${
+        this.filename
+      };base64,${contents.toString("base64")}`;
+      return new URL(dataurl);
+    }
+  }
+
   toDbRecord() {
     return {
       key: this.key,
       filename: this.filename,
       contentType: this.contentType,
-      size: this._size,
+      size: this.size,
     };
   }
 
@@ -188,14 +216,21 @@ async function storeFile(contents, key, filename, contentType, expires) {
       Key: "files/" + key,
       Body: contents,
       ContentType: contentType,
+      ContentDisposition: `attachment; filename="${encodeURIComponent(
+        this.filename
+      )}"`,
       Metadata: {
-        filename: filename,
+        filename: this.filename,
       },
       ACL: "private",
     };
 
     if (expires) {
-      params.Expires = expires;
+      if (expires instanceof Date) {
+        params.Expires = expires;
+      } else {
+        console.warn("Invalid expires value. Skipping Expires parameter.");
+      }
     }
 
     const command = new PutObjectCommand(params);
@@ -206,8 +241,7 @@ async function storeFile(contents, key, filename, contentType, expires) {
       throw error;
     }
   } else {
-    // default to db storage
-    const db = useDatabase();
+    const db = createDatabaseClient();
 
     try {
       let query = db
@@ -233,6 +267,8 @@ async function storeFile(contents, key, filename, contentType, expires) {
       await query.execute();
     } catch (e) {
       throw new DatabaseError(e);
+    } finally {
+      await db.destroy();
     }
   }
 }

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

@@ -3,7 +3,6 @@ const neonserverless = require("@neondatabase/serverless");
 const { AsyncLocalStorage } = require("async_hooks");
 const { AuditContextPlugin } = require("./auditing");
 const pg = require("pg");
-const { PROTO_ACTION_TYPES } = require("./consts");
 const { withSpan } = require("./tracing");
 const ws = require("ws");
 
@@ -14,18 +13,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) => {
@@ -70,6 +58,7 @@ function useDatabase() {
 
   // 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.
+  console.trace();
   throw new Error("useDatabase must be called within a function");
 }
 

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);
@@ -80,6 +90,7 @@ async function handleRequest(request, config) {
             return customFunction(ctx, inputs);
           }
         );
+
         if (result instanceof Error) {
           span.recordException(result);
           span.setStatus({

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

@@ -176,6 +176,9 @@ export declare class File extends InlineFile {
   get key(): string;
   // Gets size of the file's contents in bytes
   get isPublic(): boolean;
+  // Generates a presigned download URL
+  getPresignedUrl(): Promise<URL>;
+  // Creates a new instance from the database record
   static fromDbRecord(input: FileDbRecord): File;
   // Persists the file
   toDbRecord(): FileDbRecord;
@@ -224,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/parsing.test.js

@@ -106,7 +106,7 @@ test("nested image test", async () => {
   });
 });
 
-test("nested structure", async () => {
+test("arrays", async () => {
   const params = {
     names: ["james", "susan"],
     ages: [1, 2],

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 = false;
+    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 = false;
+  if (functionConfig?.dbTransaction !== undefined) {
+    requiresTransaction = functionConfig.dbTransaction;
+  }
+  return withDatabase(db, requiresTransaction, async () => {
     await withAuditContext(request, async () => {
       return cb();
     });