@teamkeel/functions-runtime 0.412.0-next.3 → 0.412.0

package/.env.test

@@ -0,0 +1,2 @@
+KEEL_DB_CONN=postgresql://postgres:postgres@localhost:7654/functions-runtime
+KEEL_DB_CONN_TYPE=pg

package/compose.yaml

@@ -0,0 +1,10 @@
+services:
+  postgres:
+    image: pgvector/pgvector:pg15
+    restart: always
+    environment:
+      - POSTGRES_USER=postgres
+      - POSTGRES_PASSWORD=postgres
+      - POSTGRES_DB=functions-runtime
+    ports:
+      - "7654:5432"

package/package.json

@@ -1,40 +1,22 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.412.0-next.3",
+  "version": "0.412.0",
   "description": "Internal package used by @teamkeel/sdk",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
-    }
-  },
+  "main": "src/index.js",
   "scripts": {
     "test": "vitest run --reporter verbose --pool=threads --poolOptions.threads.singleThread",
-    "format": "npx prettier --write src/**/*.js",
-    "build": "tsup",
-    "type-check": "tsc --noEmit",
-    "dev": "tsup --watch"
+    "format": "npx prettier --write src/**/*.js"
   },
   "keywords": [],
   "author": "Keel (www.keel.so)",
   "license": "ASL (Apache 2.0)",
+  "typings": "src/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
   "devDependencies": {
     "prettier": "3.1.1",
-    "vitest": "3.0.8",
-    "typescript": "^5.3.0",
-    "tsup": "^8.0.0",
-    "@types/node": "^22.0.0"
+    "vitest": "3.0.8"
   },
   "dependencies": {
     "@aws-sdk/client-s3": "~3.722.0",

package/src/Duration.js

@@ -0,0 +1,40 @@
+const parseInterval = require("postgres-interval");
+
+const isoRegex =
+  /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+
+class Duration {
+  constructor(postgresString) {
+    this._typename = "Duration";
+    this.pgInterval = postgresString;
+    this._interval = parseInterval(postgresString);
+  }
+
+  static fromISOString(isoString) {
+    // todo parse iso string to postgres string
+    const match = isoString.match(isoRegex);
+    if (match) {
+      let d = new Duration();
+      d._interval.years = match[1];
+      d._interval.months = match[2];
+      d._interval.days = match[3];
+      d._interval.hours = match[4];
+      d._interval.minutes = match[5];
+      d._interval.seconds = match[6];
+      return d;
+    }
+    return new Duration();
+  }
+
+  toISOString() {
+    return this._interval.toISOStringShort();
+  }
+
+  toPostgres() {
+    return this._interval.toPostgres();
+  }
+}
+
+module.exports = {
+  Duration,
+};

package/src/Duration.test.js

@@ -0,0 +1,34 @@
+import { test, expect } from "vitest";
+const { Duration } = require("./Duration");
+
+test("fromISOString test", async () => {
+  const fullDate = Duration.fromISOString("P1Y2M3DT4H5M6S");
+  expect(fullDate.toISOString()).toEqual("P1Y2M3DT4H5M6S");
+  expect(fullDate.toPostgres()).toEqual(
+    "1 years 2 months 3 days 4 hours 5 minutes 6 seconds"
+  );
+  const dateOnly = Duration.fromISOString("P2Y3M4D");
+  expect(dateOnly.toISOString()).toEqual("P2Y3M4D");
+  expect(dateOnly.toPostgres()).toEqual("2 years 3 months 4 days");
+  const timeOnly = Duration.fromISOString("PT4H5M6S");
+  expect(timeOnly.toISOString()).toEqual("PT4H5M6S");
+  expect(timeOnly.toPostgres()).toEqual("4 hours 5 minutes 6 seconds");
+  const years = Duration.fromISOString("P10Y");
+  expect(years.toISOString()).toEqual("P10Y");
+  expect(years.toPostgres()).toEqual("10 years");
+  const months = Duration.fromISOString("P20M");
+  expect(months.toISOString()).toEqual("P20M");
+  expect(months.toPostgres()).toEqual("20 months");
+  const days = Duration.fromISOString("P31D");
+  expect(days.toISOString()).toEqual("P31D");
+  expect(days.toPostgres()).toEqual("31 days");
+  const hours = Duration.fromISOString("PT4H");
+  expect(hours.toISOString()).toEqual("PT4H");
+  expect(hours.toPostgres()).toEqual("4 hours");
+  const minutes = Duration.fromISOString("PT61M");
+  expect(minutes.toISOString()).toEqual("PT61M");
+  expect(minutes.toPostgres()).toEqual("61 minutes");
+  const seconds = Duration.fromISOString("PT76S");
+  expect(seconds.toISOString()).toEqual("PT76S");
+  expect(seconds.toPostgres()).toEqual("76 seconds");
+});

package/src/File.js

@@ -0,0 +1,295 @@
+const {
+  S3Client,
+  PutObjectCommand,
+  GetObjectCommand,
+} = require("@aws-sdk/client-s3");
+const { fromEnv } = require("@aws-sdk/credential-providers");
+const { getSignedUrl } = require("@aws-sdk/s3-request-presigner");
+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;
+
+  if (!endpoint) {
+    // If no test endpoint is provided then use the env's configuration
+    return new S3Client({
+      region: process.env.KEEL_REGION,
+      credentials: fromEnv(),
+    });
+  }
+
+  return new S3Client({
+    region: process.env.KEEL_REGION,
+
+    // If a test endpoint is provided then use some test credentials
+    credentials: {
+      accessKeyId: "test",
+      secretAccessKey: "test",
+    },
+
+    // If a custom endpoint is set we need to use a custom resolver. Just setting 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 implementing a full resolver we can force it to be the endpoint we want.
+    endpointProvider: () => {
+      return {
+        url: new URL(endpoint),
+      };
+    },
+  });
+})();
+
+class InlineFile {
+  constructor({ filename, contentType }) {
+    this._filename = filename;
+    this._contentType = contentType;
+    this._contents = null;
+  }
+
+  static fromDataURL(dataURL) {
+    var info = dataURL.split(",")[0].split(":")[1];
+    var data = dataURL.split(",")[1];
+    var mime = info.split(";")[0];
+    var name = info.split(";")[1].split("=")[1];
+    var buffer = Buffer.from(data, "base64");
+    var file = new InlineFile({ filename: name, contentType: mime });
+    file.write(buffer);
+
+    return file;
+  }
+
+  get size() {
+    if (this._contents) {
+      return this._contents.size;
+    } else {
+      return 0;
+    }
+  }
+
+  get contentType() {
+    return this._contentType;
+  }
+
+  get filename() {
+    return this._filename;
+  }
+
+  write(buffer) {
+    this._contents = new Blob([buffer]);
+  }
+
+  // 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
+  async read() {
+    const arrayBuffer = await this._contents.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    return buffer;
+  }
+
+  async store(expires = null) {
+    const content = await this.read();
+    const key = KSUID.randomSync().string;
+
+    await storeFile(
+      content,
+      key,
+      this._filename,
+      this._contentType,
+      this.size,
+      expires
+    );
+
+    return new File({
+      key: key,
+      size: this.size,
+      filename: this.filename,
+      contentType: this.contentType,
+    });
+  }
+}
+
+class File extends InlineFile {
+  constructor(input) {
+    super({ filename: input.filename, contentType: input.contentType });
+    this._key = input.key;
+    this._size = input.size;
+  }
+
+  static fromDbRecord({ key, filename, size, contentType }) {
+    return new File({
+      key: key,
+      filename: filename,
+      size: size,
+      contentType: contentType,
+    });
+  }
+
+  get size() {
+    return this._size;
+  }
+
+  get key() {
+    return this._key;
+  }
+
+  async read() {
+    if (this._contents) {
+      const arrayBuffer = await this._contents.arrayBuffer();
+      return Buffer.from(arrayBuffer);
+    }
+
+    if (s3Client) {
+      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 = await 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);
+    }
+  }
+
+  async store(expires = null) {
+    // Only necessary to store the file if the contents have been changed
+    if (this._contents) {
+      const contents = await this.read();
+      await storeFile(
+        contents,
+        this.key,
+        this.filename,
+        this.contentType,
+        expires
+      );
+    }
+    return this;
+  }
+
+  async getPresignedUrl() {
+    if (s3Client) {
+      const command = new GetObjectCommand({
+        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+        Key: "files/" + this.key,
+        ResponseContentDisposition: "inline",
+      });
+
+      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,
+    };
+  }
+
+  toJSON() {
+    return {
+      key: this.key,
+      filename: this.filename,
+      contentType: this.contentType,
+      size: this.size,
+    };
+  }
+}
+
+async function storeFile(contents, key, filename, contentType, expires) {
+  if (s3Client) {
+    const params = {
+      Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+      Key: "files/" + key,
+      Body: contents,
+      ContentType: contentType,
+      ContentDisposition: `attachment; filename="${encodeURIComponent(
+        filename
+      )}"`,
+      Metadata: {
+        filename: filename,
+      },
+      ACL: "private",
+    };
+
+    if (expires) {
+      if (expires instanceof Date) {
+        params.Expires = expires;
+      } else {
+        console.warn("Invalid expires value. Skipping Expires parameter.");
+      }
+    }
+
+    const command = new PutObjectCommand(params);
+    try {
+      await s3Client.send(command);
+    } catch (error) {
+      console.error("Error uploading file:", error);
+      throw error;
+    }
+  } else {
+    const db = useDatabase();
+
+    try {
+      let query = db
+        .insertInto("keel_storage")
+        .values({
+          id: key,
+          filename: filename,
+          content_type: contentType,
+          data: contents,
+        })
+        .onConflict((oc) =>
+          oc
+            .column("id")
+            .doUpdateSet(() => ({
+              filename: filename,
+              content_type: contentType,
+              data: contents,
+            }))
+            .where("keel_storage.id", "=", key)
+        )
+        .returningAll();
+
+      await query.execute();
+    } catch (e) {
+      throw new DatabaseError(e);
+    }
+  }
+}
+
+module.exports = {
+  InlineFile,
+  File,
+};