@teamkeel/functions-runtime 0.390.0 → 0.391.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.390.0",
+  "version": "0.391.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
@@ -19,6 +19,8 @@
     "vitest": "^0.34.6"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.617.0",
+    "@aws-sdk/credential-providers": "^3.617.0",
     "@neondatabase/serverless": "^0.9.3",
     "@opentelemetry/api": "^1.7.0",
     "@opentelemetry/exporter-trace-otlp-proto": "^0.46.0",

package/src/InlineFile.js

@@ -1,9 +1,21 @@
+const {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+} = require("@aws-sdk/client-s3");
+const { fromEnv } = require("@aws-sdk/credential-providers");
+const { useDatabase } = require("./database");
+const { DatabaseError } = require("./errors");
+const KSUID = require("ksuid");
+
 class InlineFile {
-  constructor(filename, contentType, size, url) {
+  constructor(filename, contentType, size, url, key, pub) {
     this.filename = filename;
     this.contentType = contentType;
     this.size = size;
     this.url = url;
+    this.key = key;
+    this.public = pub || false;
   }
 
   // Create an InlineFile instance from a given json object.
@@ -14,7 +26,14 @@ class InlineFile {
       return file;
     }
 
-    return new InlineFile(obj.filename, obj.contentType, obj.size, obj.url);
+    return new InlineFile(
+      obj.filename,
+      obj.contentType,
+      obj.size,
+      obj.url,
+      obj.key,
+      obj.public
+    );
   }
 
   // Create an InlineFile instance from a given dataURL
@@ -34,21 +53,112 @@ class InlineFile {
 
   // Read the contents of the file. If URL is set, it will be read from the remote storage, otherwise, if dataURL is set
   // on the instance, it will return a blob with the file contents
-  read() {
-    if (this.url) {
-      // TODO: read from store
-    }
-
+  async read() {
     if (this._dataURL) {
       var data = this._dataURL.split(",")[1];
-      var byteString = Buffer.from(data, "base64");
-      return new Blob([byteString], { type: this.contentType });
+      return Buffer.from(data, "base64");
+    }
+
+    // if we don't have a key nor a dataURL, this inline file has no data
+    if (!this.key) {
+      throw new Error("invalid file data");
+    }
+
+    if (isS3Storage()) {
+      const s3Client = new S3Client({
+        credentials: fromEnv(),
+        region: process.env.KEEL_REGION,
+      });
+
+      const params = {
+        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+        Key: "files/" + this.key,
+      };
+      const command = new GetObjectCommand(params);
+      const response = await s3Client.send(command);
+      const blob = response.Body.transformToByteArray();
+      return Buffer.from(blob);
+    }
+
+    // default to db storage
+    const db = useDatabase();
+
+    try {
+      let query = db
+        .selectFrom("keel_storage")
+        .select("data")
+        .where("id", "=", this.key);
+
+      const row = await query.executeTakeFirstOrThrow();
+      return row.data;
+    } catch (e) {
+      throw new DatabaseError(e);
     }
   }
 
-  store() {
-    //TODO: actually store and generate a key
-    this.key = uuidv4();
+  async store(expires = null) {
+    const content = await this.read();
+    this.key = KSUID.randomSync().string;
+
+    if (isS3Storage()) {
+      const s3Client = new S3Client({
+        credentials: fromEnv(),
+        region: process.env.KEEL_REGION,
+      });
+
+      const params = {
+        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+        Key: "files/" + this.key,
+        Body: content,
+        ContentType: this.contentType,
+        Metadata: {
+          filename: this.filename,
+        },
+        ACL: this.public ? "public-read" : "private",
+      };
+
+      if (expires) {
+        params.Expires = expires;
+      }
+
+      const command = new PutObjectCommand(params);
+      try {
+        await s3Client.send(command);
+
+        return {
+          key: this.key,
+          size: this.size,
+          filename: this.filename,
+          contentType: this.contentType,
+          public: this.public,
+        };
+      } catch (error) {
+        console.error("Error uploading file:", error);
+        throw error;
+      }
+    }
+
+    // default to db storage
+    const db = useDatabase();
+
+    try {
+      let query = db.insertInto("keel_storage").values({
+        id: this.key,
+        filename: this.filename,
+        content_type: this.contentType,
+        data: content,
+      });
+
+      await query.returningAll().executeTakeFirstOrThrow();
+      return {
+        key: this.key,
+        size: this.size,
+        filename: this.filename,
+        contentType: this.contentType,
+      };
+    } catch (e) {
+      throw new DatabaseError(e);
+    }
   }
 
   toJSON() {
@@ -59,6 +169,7 @@ class InlineFile {
       contentType: this.contentType,
       size: this.size,
       url: this.url,
+      public: this.public,
     };
   }
 }
@@ -66,3 +177,7 @@ class InlineFile {
 module.exports = {
   InlineFile,
 };
+
+function isS3Storage() {
+  return "KEEL_FILES_BUCKET_NAME" in process.env;
+}

package/src/ModelAPI.js

@@ -4,6 +4,7 @@ const { QueryBuilder } = require("./QueryBuilder");
 const { QueryContext } = require("./QueryContext");
 const { applyWhereConditions } = require("./applyWhereConditions");
 const { applyJoins } = require("./applyJoins");
+const { InlineFile } = require("./InlineFile");
 
 const {
   applyLimit,
@@ -84,7 +85,7 @@ class ModelAPI {
         return null;
       }
 
-      return camelCaseObject(row);
+      return transformRichDataTypes(camelCaseObject(row));
     });
   }
 
@@ -140,7 +141,7 @@ class ModelAPI {
 
       span.setAttribute("sql", query.compile().sql);
       const rows = await builder.execute();
-      return rows.map((x) => camelCaseObject(x));
+      return rows.map((x) => transformRichDataTypes(camelCaseObject(x)));
     });
   }
 
@@ -151,7 +152,21 @@ class ModelAPI {
     return tracing.withSpan(name, async (span) => {
       let builder = db.updateTable(this._tableName).returningAll();
 
-      builder = builder.set(snakeCaseObject(values));
+      // process input values
+      const keys = values ? Object.keys(values) : [];
+      const row = {};
+
+      for (const key of keys) {
+        const value = values[key];
+        // handle files that need uploading
+        if (value instanceof InlineFile) {
+          const dbValue = await value.store();
+          row[key] = dbValue;
+        } else {
+          row[key] = value;
+        }
+      }
+      builder = builder.set(snakeCaseObject(row));
 
       const context = new QueryContext([this._tableName], this._tableConfigMap);
 
@@ -226,7 +241,14 @@ async function create(conn, tableName, tableConfigs, values) {
         const columnConfig = tableConfig[key];
 
         if (!columnConfig) {
-          row[key] = value;
+          // handle files that need uploading
+          if (value instanceof InlineFile) {
+            const dbValue = await value.store();
+            row[key] = dbValue;
+          } else {
+            row[key] = value;
+          }
+
           continue;
         }
 
@@ -305,6 +327,29 @@ async function create(conn, tableName, tableConfigs, values) {
   }
 }
 
+// Iterate through the given object's keys and if any of the values are a rich data type, instantiate their respective class
+function transformRichDataTypes(data) {
+  const keys = data ? Object.keys(data) : [];
+  const row = {};
+
+  for (const key of keys) {
+    const value = data[key];
+    if (isPlainObject(value)) {
+      // if we've got an InlineFile...
+      if (value.key && value.size && value.filename && value.contentType) {
+        row[key] = InlineFile.fromObject(value);
+      } else {
+        row[key] = value;
+      }
+      continue;
+    }
+
+    row[key] = value;
+  }
+
+  return row;
+}
+
 function isPlainObject(obj) {
   return Object.prototype.toString.call(obj) === "[object Object]";
 }