@teamkeel/functions-runtime 0.402.1 → 0.404.0

package/package.json

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

package/src/File.js

@@ -9,6 +9,37 @@ const { useDatabase } = require("./database");
 const { DatabaseError } = require("./errors");
 const KSUID = require("ksuid");
 
+const s3Client = (() => {
+  if (!process.env.KEEL_FILES_BUCKET_NAME) {
+    return null;
+  }
+
+  // Set in integration tests to send all AWS API calls to a test server
+  // for mocking
+  const endpoint = process.env.TEST_AWS_ENDPOINT;
+
+  return new S3Client({
+    region: process.env.KEEL_REGION,
+
+    // If a test endpoint is provided then use some test credentials rather than fromEnv()
+    credentials: endpoint
+      ? {
+          accessKeyId: "test",
+          secretAccessKey: "test",
+        }
+      : fromEnv(),
+
+    // If a custom endpoint is set we need to use a custom resolver. Just settng the base endpoint isn't enough for S3 as it
+    // as the default resolver uses the bucket name as a sub-domain, which likely won't work with the custom endpoint.
+    // By impleenting a full resolver we can force it to be the endpoint we want.
+    endpointProvider: () => {
+      return {
+        url: URL.parse(endpoint),
+      };
+    },
+  });
+})();
+
 class InlineFile {
   constructor({ filename, contentType }) {
     this._filename = filename;
@@ -109,12 +140,7 @@ class File extends InlineFile {
       return Buffer.from(arrayBuffer);
     }
 
-    if (isS3Storage()) {
-      const s3Client = new S3Client({
-        credentials: fromEnv(),
-        region: process.env.KEEL_REGION,
-      });
-
+    if (s3Client) {
       const params = {
         Bucket: process.env.KEEL_FILES_BUCKET_NAME,
         Key: "files/" + this.key,
@@ -157,12 +183,7 @@ class File extends InlineFile {
   }
 
   async getPresignedUrl() {
-    if (isS3Storage()) {
-      const s3Client = new S3Client({
-        credentials: fromEnv(),
-        region: process.env.KEEL_REGION,
-      });
-
+    if (s3Client) {
       const command = new GetObjectCommand({
         Bucket: process.env.KEEL_FILES_BUCKET_NAME,
         Key: "files/" + this.key,
@@ -203,12 +224,7 @@ class File extends InlineFile {
 }
 
 async function storeFile(contents, key, filename, contentType, expires) {
-  if (isS3Storage()) {
-    const s3Client = new S3Client({
-      credentials: fromEnv(),
-      region: process.env.KEEL_REGION,
-    });
-
+  if (s3Client) {
     const params = {
       Bucket: process.env.KEEL_FILES_BUCKET_NAME,
       Key: "files/" + key,
@@ -269,10 +285,6 @@ async function storeFile(contents, key, filename, contentType, expires) {
   }
 }
 
-function isS3Storage() {
-  return "KEEL_FILES_BUCKET_NAME" in process.env;
-}
-
 module.exports = {
   InlineFile,
   File,

package/src/ModelAPI.js

@@ -164,11 +164,25 @@ class ModelAPI {
 
       for (const key of keys) {
         const value = values[key];
-        if (value instanceof Duration) {
+        if (Array.isArray(value)) {
+          row[key] = await Promise.all(
+            value.map(async (item) => {
+              if (item instanceof Duration) {
+                return item.toPostgres();
+              }
+              if (item instanceof InlineFile) {
+                const storedFile = await item.store();
+                return storedFile.toDbRecord();
+              }
+              if (item instanceof File) {
+                return item.toDbRecord();
+              }
+              return item;
+            })
+          );
+        } else if (value instanceof Duration) {
           row[key] = value.toPostgres();
-        }
-        // handle files that need uploading
-        if (value instanceof InlineFile) {
+        } else if (value instanceof InlineFile) {
           const storedFile = await value.store();
           row[key] = storedFile.toDbRecord();
         } else if (value instanceof File) {
@@ -253,10 +267,25 @@ async function create(conn, tableName, tableConfigs, values) {
         const columnConfig = tableConfig[key];
 
         if (!columnConfig) {
-          if (value instanceof Duration) {
+          if (Array.isArray(value)) {
+            row[key] = await Promise.all(
+              value.map(async (item) => {
+                if (item instanceof Duration) {
+                  return item.toPostgres();
+                }
+                if (item instanceof InlineFile) {
+                  const storedFile = await item.store();
+                  return storedFile.toDbRecord();
+                }
+                if (item instanceof File) {
+                  return item.toDbRecord();
+                }
+                return item;
+              })
+            );
+          } else if (value instanceof Duration) {
             row[key] = value.toPostgres();
-          }
-          if (value instanceof InlineFile) {
+          } else if (value instanceof InlineFile) {
             const storedFile = await value.store();
             row[key] = storedFile.toDbRecord();
           } else if (value instanceof File) {

package/src/index.d.ts

@@ -313,3 +313,5 @@ export type DurationString =
   | `P${dateDuration}T${timeDuration}`
   | `P${dateDuration}`
   | `PT${timeDuration}`;
+
+export type FileWriteTypes = InlineFile | File;

package/src/parsing.js

@@ -5,22 +5,24 @@ const { isPlainObject } = require("./type-utils");
 // parseInputs takes a set of inputs and creates objects for the ones that are of a complex type.
 //
 // inputs that are objects and contain a "__typename" field are resolved to instances of the complex type
-// they represent. At the moment, the only supported type is `InlineFile`
+// they represent.
 function parseInputs(inputs) {
   if (inputs != null && typeof inputs === "object") {
     for (const k of Object.keys(inputs)) {
       if (inputs[k] !== null && typeof inputs[k] === "object") {
-        if ("__typename" in inputs[k]) {
-          switch (inputs[k].__typename) {
-            case "InlineFile":
-              inputs[k] = InlineFile.fromDataURL(inputs[k].dataURL);
-              break;
-            case "Duration":
-              inputs[k] = Duration.fromISOString(inputs[k].interval);
-              break;
-            default:
-              break;
-          }
+        if (Array.isArray(inputs[k])) {
+          inputs[k] = inputs[k].map((item) => {
+            if (item && typeof item === "object") {
+              if ("__typename" in item) {
+                return parseComplexInputType(item);
+              }
+              // Recursively parse nested objects in arrays
+              return parseInputs(item);
+            }
+            return item;
+          });
+        } else if ("__typename" in inputs[k]) {
+          inputs[k] = parseComplexInputType(inputs[k]);
         } else {
           inputs[k] = parseInputs(inputs[k]);
         }
@@ -31,26 +33,42 @@ function parseInputs(inputs) {
   return inputs;
 }
 
+// parseComplexInputType will parse out complex types such as InlineFile and Duration
+function parseComplexInputType(value) {
+  switch (value.__typename) {
+    case "InlineFile":
+      return InlineFile.fromDataURL(value.dataURL);
+    case "Duration":
+      return Duration.fromISOString(value.interval);
+    default:
+      throw new Error("complex type not handled: " + value.__typename);
+  }
+}
+
 // parseOutputs will take a response from the custom function and perform operations on any fields if necessary.
 //
 // For example, InlineFiles need to be stored before returning the response.
-async function parseOutputs(inputs) {
-  if (inputs != null && typeof inputs === "object") {
-    for (const k of Object.keys(inputs)) {
-      if (inputs[k] !== null && typeof inputs[k] === "object") {
-        if (inputs[k] instanceof InlineFile) {
-          const stored = await inputs[k].store();
-          inputs[k] = stored;
-        } else if (inputs[k] instanceof Duration) {
-          inputs[k] = inputs[k].toISOString();
+async function parseOutputs(outputs) {
+  if (outputs != null && typeof outputs === "object") {
+    for (const k of Object.keys(outputs)) {
+      if (outputs[k] !== null && typeof outputs[k] === "object") {
+        if (Array.isArray(outputs[k])) {
+          outputs[k] = await Promise.all(
+            outputs[k].map((item) => parseOutputs(item))
+          );
+        } else if (outputs[k] instanceof InlineFile) {
+          const stored = await outputs[k].store();
+          outputs[k] = stored;
+        } else if (outputs[k] instanceof Duration) {
+          outputs[k] = outputs[k].toISOString();
         } else {
-          inputs[k] = await parseOutputs(inputs[k]);
+          outputs[k] = await parseOutputs(outputs[k]);
         }
       }
     }
   }
 
-  return inputs;
+  return outputs;
 }
 
 // transformRichDataTypes iterates through the given object's keys and if any of the values are a rich data type, instantiate their respective class
@@ -60,7 +78,9 @@ function transformRichDataTypes(data) {
 
   for (const key of keys) {
     const value = data[key];
-    if (isPlainObject(value)) {
+    if (Array.isArray(value)) {
+      row[key] = value.map((item) => transformRichDataTypes({ item }).item);
+    } else if (isPlainObject(value)) {
       if (value._typename == "Duration" && value.pgInterval) {
         row[key] = new Duration(value.pgInterval);
       } else if (
@@ -73,10 +93,9 @@ function transformRichDataTypes(data) {
       } else {
         row[key] = value;
       }
-      continue;
+    } else {
+      row[key] = value;
     }
-
-    row[key] = value;
   }
 
   return row;