@teamkeel/functions-runtime 0.403.0 → 0.404.1

package/package.json

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

package/src/File.js

@@ -187,9 +187,7 @@ class File extends InlineFile {
       const command = new GetObjectCommand({
         Bucket: process.env.KEEL_FILES_BUCKET_NAME,
         Key: "files/" + this.key,
-        ResponseContentDisposition: `attachment; filename="${encodeURIComponent(
-          this.filename
-        )}"`,
+        ResponseContentDisposition: "inline",
       });
 
       const url = await getSignedUrl(s3Client, command, { expiresIn: 60 * 60 });

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;