@teamkeel/functions-runtime 0.398.0 → 0.399.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.398.0",
+  "version": "0.399.1",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
@@ -33,6 +33,7 @@
     "ksuid": "^3.0.0",
     "kysely": "~0.25.0",
     "pg": "^8.13.1",
+    "postgres-interval": "^4.0.2",
     "traceparent": "^1.0.0",
     "ws": "^8.18.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/ModelAPI.js

@@ -2,14 +2,15 @@ const { sql } = require("kysely");
 const { useDatabase } = require("./database");
 const {
   transformRichDataTypes,
-  isPlainObject,
   isReferencingExistingRecord,
 } = require("./parsing");
+const { isPlainObject } = require("./type-utils");
 const { QueryBuilder } = require("./QueryBuilder");
 const { QueryContext } = require("./QueryContext");
 const { applyWhereConditions } = require("./applyWhereConditions");
 const { applyJoins } = require("./applyJoins");
 const { InlineFile, File } = require("./File");
+const { Duration } = require("./Duration");
 
 const {
   applyLimit,
@@ -163,6 +164,9 @@ class ModelAPI {
 
       for (const key of keys) {
         const value = values[key];
+        if (value instanceof Duration) {
+          row[key] = value.toPostgres();
+        }
         // handle files that need uploading
         if (value instanceof InlineFile) {
           const storedFile = await value.store();
@@ -249,6 +253,9 @@ async function create(conn, tableName, tableConfigs, values) {
         const columnConfig = tableConfig[key];
 
         if (!columnConfig) {
+          if (value instanceof Duration) {
+            row[key] = value.toPostgres();
+          }
           if (value instanceof InlineFile) {
             const storedFile = await value.store();
             row[key] = storedFile.toDbRecord();

package/src/camelCasePlugin.js

@@ -0,0 +1,48 @@
+const { CamelCasePlugin } = require("kysely");
+const { isPlainObject, isRichType } = require("./type-utils");
+
+// KeelCamelCasePlugin is a wrapper around kysely's CamelCasePlugin. The behaviour is the same apart from the fact that
+// nested objects that are of a rich keel data type, such as Duration, are skipped so that they continue to be
+// implementations of the rich data classes defined by Keel.
+class KeelCamelCasePlugin {
+  constructor(opt) {
+    this.opt = opt;
+    this.CamelCasePlugin = new CamelCasePlugin(opt);
+  }
+
+  transformQuery(args) {
+    return this.CamelCasePlugin.transformQuery(args);
+  }
+
+  async transformResult(args) {
+    if (args.result.rows && Array.isArray(args.result.rows)) {
+      return {
+        ...args.result,
+        rows: args.result.rows.map((row) => this.mapRow(row)),
+      };
+    }
+    return args.result;
+  }
+  mapRow(row) {
+    return Object.keys(row).reduce((obj, key) => {
+      let value = row[key];
+      if (Array.isArray(value)) {
+        value = value.map((it) =>
+          canMap(it, this.opt) ? this.mapRow(it) : it
+        );
+      } else if (canMap(value, this.opt)) {
+        value = this.mapRow(value);
+      }
+      obj[this.CamelCasePlugin.camelCase(key)] = value;
+      return obj;
+    }, {});
+  }
+}
+
+function canMap(obj, opt) {
+  return (
+    isPlainObject(obj) && !opt?.maintainNestedObjectKeys && !isRichType(obj)
+  );
+}
+
+module.exports.KeelCamelCasePlugin = KeelCamelCasePlugin;

package/src/database.js

@@ -1,11 +1,13 @@
-const { Kysely, PostgresDialect, CamelCasePlugin } = require("kysely");
+const { Kysely, PostgresDialect } = require("kysely");
 const neonserverless = require("@neondatabase/serverless");
 const { AsyncLocalStorage } = require("async_hooks");
 const { AuditContextPlugin } = require("./auditing");
+const { KeelCamelCasePlugin } = require("./camelCasePlugin");
 const pg = require("pg");
 const { withSpan } = require("./tracing");
 const ws = require("ws");
 const fs = require("node:fs");
+const { Duration } = require("./Duration");
 
 // withDatabase is responsible for setting the correct database client in our AsyncLocalStorage
 // so that the the code in a custom function uses the correct client.
@@ -74,10 +76,9 @@ function createDatabaseClient({ connString } = {}) {
       new AuditContextPlugin(),
       // allows users to query using camelCased versions of the database column names, which
       // should match the names we use in our schema.
-      // https://kysely-org.github.io/kysely/classes/CamelCasePlugin.html
-      // If they don't, then we can create a custom implementation of the plugin where we control
-      // the casing behaviour (see url above for example)
-      new CamelCasePlugin(),
+      // We're using an extended version of Kysely's CamelCasePlugin which avoids changing keys of objects that represent
+      // rich data formats, specific to Keel (e.g. Duration)
+      new KeelCamelCasePlugin(),
     ],
     log(event) {
       if ("DEBUG" in process.env) {
@@ -146,9 +147,14 @@ function getDialect(connString) {
     case "pg":
       // Adding a custom type parser for numeric fields: see https://kysely.dev/docs/recipes/data-types#configuring-runtime-javascript-types
       // 1700 = type for NUMERIC
-      pg.types.setTypeParser(1700, function (val) {
+      pg.types.setTypeParser(pg.types.builtins.NUMERIC, function (val) {
         return parseFloat(val);
       });
+      // Adding a custom type parser for interval fields: see https://kysely.dev/docs/recipes/data-types#configuring-runtime-javascript-types
+      // 1186 = type for INTERVAL
+      pg.types.setTypeParser(pg.types.builtins.INTERVAL, function (val) {
+        return new Duration(val);
+      });
 
       return new PostgresDialect({
         pool: new InstrumentedPool({
@@ -179,9 +185,20 @@ function getDialect(connString) {
     case "neon":
       // Adding a custom type parser for numeric fields: see https://kysely.dev/docs/recipes/data-types#configuring-runtime-javascript-types
       // 1700 = type for NUMERIC
-      neonserverless.types.setTypeParser(1700, function (val) {
-        return parseFloat(val);
-      });
+      neonserverless.types.setTypeParser(
+        pg.types.builtins.NUMERIC,
+        function (val) {
+          return parseFloat(val);
+        }
+      );
+      // Adding a custom type parser for interval fields: see https://kysely.dev/docs/recipes/data-types#configuring-runtime-javascript-types
+      // 1186 = type for INTERVAL
+      neonserverless.types.setTypeParser(
+        pg.types.builtins.INTERVAL,
+        function (val) {
+          return new Duration(val);
+        }
+      );
 
       neonserverless.neonConfig.webSocketConstructor = ws;
 

package/src/index.d.ts

@@ -27,6 +27,15 @@ export type NumberWhereCondition = {
   notEquals?: number | null;
 };
 
+export type DurationWhereCondition = {
+  greaterThan?: DurationString | null;
+  greaterThanOrEquals?: DurationString | null;
+  lessThan?: DurationString | null;
+  lessThanOrEquals?: DurationString | null;
+  equals?: DurationString | null;
+  notEquals?: DurationString | null;
+};
+
 export type DateWhereCondition = {
   equals?: Date | string | null;
   equalsRelative?: RelativeDateString | null;
@@ -197,6 +206,14 @@ export type FileDbRecord = {
   size: number;
 };
 
+export declare class Duration {
+  constructor(postgresString: string);
+  static fromISOString(iso: DurationString): Duration;
+
+  toISOString(): DurationString;
+  toPostgres(): string;
+}
+
 export type SortDirection = "asc" | "desc" | "ASC" | "DESC";
 
 // Request headers cannot be mutated, so remove any methods that mutate
@@ -272,3 +289,26 @@ export type RelativeDateString =
   | `${direction} ${unit}`
   | `${direction} ${value} ${unit}`
   | `${direction} ${value} ${completed} ${unit}`;
+
+type dateDuration =
+  | `${number}Y${number}M${number}D` // Example: 1Y2M10D
+  | `${number}Y${number}M` // Example: 1Y2M
+  | `${number}Y${number}D` // Example: 1Y10D
+  | `${number}M${number}D` // Example: 10M2D
+  | `${number}Y` // Example: 1Y
+  | `${number}M` // Example: 1M
+  | `${number}D`; // Example: 2D
+
+type timeDuration =
+  | `${number}H${number}M${number}S` // Example: 2H30M
+  | `${number}H${number}M` // Example: 2H30M
+  | `${number}M${number}S` // Example: 2M30S
+  | `${number}H${number}S` // Example: 2H30S
+  | `${number}H` // Example: 2H
+  | `${number}M` // Example: 30M
+  | `${number}S`; // Example: 30S
+
+export type DurationString =
+  | `P${dateDuration}T${timeDuration}`
+  | `P${dateDuration}`
+  | `PT${timeDuration}`;

package/src/index.js

@@ -12,6 +12,7 @@ const {
 } = require("./permissions");
 const tracing = require("./tracing");
 const { InlineFile, File } = require("./File");
+const { Duration } = require("./Duration");
 const { ErrorPresets } = require("./errors");
 
 module.exports = {
@@ -21,6 +22,7 @@ module.exports = {
   handleJob,
   handleSubscriber,
   useDatabase,
+  Duration,
   InlineFile,
   File,
   Permissions,

package/src/parsing.js

@@ -1,4 +1,6 @@
+const { Duration } = require("./Duration");
 const { InlineFile, File } = require("./File");
+const { isPlainObject } = require("./type-utils");
 
 // parseInputs takes a set of inputs and creates objects for the ones that are of a complex type.
 //
@@ -13,6 +15,9 @@ function parseInputs(inputs) {
             case "InlineFile":
               inputs[k] = InlineFile.fromDataURL(inputs[k].dataURL);
               break;
+            case "Duration":
+              inputs[k] = Duration.fromISOString(inputs[k].interval);
+              break;
             default:
               break;
           }
@@ -36,6 +41,8 @@ async function parseOutputs(inputs) {
         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();
         } else {
           inputs[k] = await parseOutputs(inputs[k]);
         }
@@ -54,7 +61,14 @@ function transformRichDataTypes(data) {
   for (const key of keys) {
     const value = data[key];
     if (isPlainObject(value)) {
-      if (value.key && value.size && value.filename && value.contentType) {
+      if (value._typename == "Duration" && value.pgInterval) {
+        row[key] = new Duration(value.pgInterval);
+      } else if (
+        value.key &&
+        value.size &&
+        value.filename &&
+        value.contentType
+      ) {
         row[key] = File.fromDbRecord(value);
       } else {
         row[key] = value;
@@ -68,10 +82,6 @@ function transformRichDataTypes(data) {
   return row;
 }
 
-function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
-}
-
 function isReferencingExistingRecord(value) {
   return Object.keys(value).length === 1 && value.id;
 }
@@ -80,6 +90,5 @@ module.exports = {
   parseInputs,
   parseOutputs,
   transformRichDataTypes,
-  isPlainObject,
   isReferencingExistingRecord,
 };

package/src/type-utils.js

@@ -0,0 +1,18 @@
+const { Duration } = require("./Duration");
+
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+
+function isRichType(obj) {
+  if (!isPlainObject(obj)) {
+    return false;
+  }
+
+  return obj instanceof Duration;
+}
+
+module.exports = {
+  isPlainObject,
+  isRichType,
+};