@teamkeel/functions-runtime 0.373.1 → 0.375.0

package/.env.test

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

package/compose.yaml

@@ -7,4 +7,4 @@ services:
       - POSTGRES_PASSWORD=postgres
       - POSTGRES_DB=functions-runtime
     ports:
-      - "5432:5432"
+      - "7654:5432"

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.373.1",
+  "version": "0.375.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
-    "test": "DEBUG=true vitest run --reporter verbose --threads false",
+    "test": "vitest run --reporter verbose --threads false",
     "format": "npx prettier --write src/**/*.js"
   },
   "keywords": [],
@@ -15,20 +15,20 @@
     "access": "public"
   },
   "devDependencies": {
-    "prettier": "2.7.1",
-    "vitest": "^0.27.1"
+    "prettier": "3.1.1",
+    "vitest": "^0.34.6"
   },
   "dependencies": {
-    "@opentelemetry/api": "^1.4.1",
-    "@opentelemetry/exporter-trace-otlp-proto": "^0.38.0",
-    "@opentelemetry/resources": "^1.12.0",
-    "@opentelemetry/sdk-trace-base": "^1.12.0",
-    "@opentelemetry/sdk-trace-node": "^1.12.0",
+    "@opentelemetry/api": "^1.7.0",
+    "@opentelemetry/exporter-trace-otlp-proto": "^0.46.0",
+    "@opentelemetry/resources": "^1.19.0",
+    "@opentelemetry/sdk-trace-base": "^1.19.0",
+    "@opentelemetry/sdk-trace-node": "^1.19.0",
     "change-case": "^4.1.2",
-    "json-rpc-2.0": "^1.4.1",
+    "json-rpc-2.0": "^1.7.0",
     "ksuid": "^3.0.0",
-    "kysely": "^0.23.4",
-    "pg": "^8.8.0",
+    "kysely": "^0.23.5",
+    "pg": "^8.11.3",
     "traceparent": "^1.0.0"
   }
 }

package/src/ModelAPI.js

@@ -1,3 +1,4 @@
+const { sql } = require("kysely");
 const { useDatabase } = require("./database");
 const { QueryBuilder } = require("./QueryBuilder");
 const { QueryContext } = require("./QueryContext");
@@ -50,26 +51,10 @@ class ModelAPI {
 
   async create(values) {
     const name = tracing.spanNameForModelAPI(this._modelName, "create");
-    const db = useDatabase();
 
-    return tracing.withSpan(name, async (span) => {
-      try {
-        const query = db
-          .insertInto(this._tableName)
-          .values(
-            snakeCaseObject({
-              ...values,
-            })
-          )
-          .returningAll();
-
-        span.setAttribute("sql", query.compile().sql);
-        const row = await query.executeTakeFirstOrThrow();
-
-        return camelCaseObject(row);
-      } catch (e) {
-        throw new DatabaseError(e);
-      }
+    return tracing.withSpan(name, () => {
+      const db = useDatabase();
+      return create(db, this._tableName, this._tableConfigMap, values);
     });
   }
 
@@ -218,6 +203,111 @@ class ModelAPI {
   }
 }
 
+async function create(conn, tableName, tableConfigs, values) {
+  try {
+    let query = conn.insertInto(tableName);
+
+    const keys = values ? Object.keys(values) : [];
+    const tableConfig = tableConfigs[tableName] || {};
+    const hasManyRecords = [];
+
+    if (keys.length === 0) {
+      // See https://github.com/kysely-org/kysely/issues/685#issuecomment-1711240534
+      query = query.expression(sql`default values`);
+    } else {
+      const row = {};
+      for (const key of keys) {
+        const value = values[key];
+        const columnConfig = tableConfig[key];
+
+        if (!columnConfig) {
+          row[key] = value;
+          continue;
+        }
+
+        switch (columnConfig.relationshipType) {
+          case "belongsTo":
+            if (!isPlainObject(value)) {
+              throw new Error(
+                `non-object provided for field ${key} of ${tableName}`
+              );
+            }
+
+            if (isReferencingExistingRecord(value)) {
+              row[columnConfig.foreignKey] = value.id;
+              break;
+            }
+
+            const created = await create(
+              conn,
+              columnConfig.referencesTable,
+              tableConfigs,
+              value
+            );
+            row[columnConfig.foreignKey] = created.id;
+            break;
+
+          case "hasMany":
+            if (!Array.isArray(value)) {
+              throw new Error(
+                `non-array provided for has-many field ${key} of ${tableName}`
+              );
+            }
+            for (const v of value) {
+              hasManyRecords.push({
+                key,
+                value: v,
+                columnConfig,
+              });
+            }
+            break;
+          default:
+            throw new Error(
+              `unsupported relationship type - ${tableName}.${key} (${columnConfig.relationshipType})`
+            );
+        }
+      }
+
+      query = query.values(row);
+    }
+
+    const created = await query.returningAll().executeTakeFirstOrThrow();
+
+    await Promise.all(
+      hasManyRecords.map(async ({ key, value, columnConfig }) => {
+        if (!isPlainObject(value)) {
+          throw new Error(
+            `non-object provided for field ${key} of ${tableName}`
+          );
+        }
+
+        if (isReferencingExistingRecord(value)) {
+          throw new Error(
+            `nested update as part of create not supported for ${key} of ${tableConfig}`
+          );
+        }
+
+        await create(conn, columnConfig.referencesTable, tableConfigs, {
+          ...value,
+          [columnConfig.foreignKey]: created.id,
+        });
+      })
+    );
+
+    return created;
+  } catch (e) {
+    throw new DatabaseError(e);
+  }
+}
+
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+
+function isReferencingExistingRecord(value) {
+  return Object.keys(value).length === 1 && value.id;
+}
+
 module.exports = {
   ModelAPI,
   DatabaseError,

package/src/ModelAPI.test.js

@@ -517,6 +517,46 @@ test("ModelAPI.findMany - orderBy", async () => {
   expect(descendingDates.map((r) => r.name)).toEqual(["Sally", "Bob", "Jim"]);
 });
 
+test("ModelAPI.findMany - orderBy ASC and DESC capitalised", async () => {
+  await personAPI.create({
+    id: KSUID.randomSync().string,
+    name: "Jim",
+    married: false,
+    favouriteNumber: 10,
+    date: new Date(2023, 12, 29),
+  });
+  await personAPI.create({
+    id: KSUID.randomSync().string,
+    name: "Bob",
+    married: true,
+    favouriteNumber: 11,
+    date: new Date(2023, 12, 30),
+  });
+  await personAPI.create({
+    id: KSUID.randomSync().string,
+    name: "Sally",
+    married: true,
+    favouriteNumber: 12,
+    date: new Date(2023, 12, 31),
+  });
+
+  const ascendingNames = await personAPI.findMany({
+    orderBy: {
+      name: "ASC",
+    },
+  });
+
+  expect(ascendingNames.map((r) => r.name)).toEqual(["Bob", "Jim", "Sally"]);
+
+  const descendingNames = await personAPI.findMany({
+    orderBy: {
+      name: "DESC",
+    },
+  });
+
+  expect(descendingNames.map((r) => r.name)).toEqual(["Sally", "Jim", "Bob"]);
+});
+
 test("ModelAPI.findMany - offset", async () => {
   await personAPI.create({
     id: KSUID.randomSync().string,

package/src/applyAdditionalQueryConstraints.js

@@ -10,7 +10,7 @@ function applyOffset(context, qb, offset) {
 
 function applyOrderBy(context, qb, tableName, orderBy = {}) {
   Object.entries(orderBy).forEach(([key, sortOrder]) => {
-    qb = qb.orderBy(`${tableName}.${snakeCase(key)}`, sortOrder);
+    qb = qb.orderBy(`${tableName}.${snakeCase(key)}`, sortOrder.toLowerCase());
   });
   return qb;
 }

package/src/handleJob.test.js

@@ -99,9 +99,6 @@ describe("ModelAPI error handling", () => {
   let db;
 
   beforeEach(async () => {
-    process.env.KEEL_DB_CONN_TYPE = "pg";
-    process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
-
     db = useDatabase();
 
     await sql`

package/src/handleRequest.test.js

@@ -218,9 +218,6 @@ describe("ModelAPI error handling", () => {
   let db;
 
   beforeEach(async () => {
-    process.env.KEEL_DB_CONN_TYPE = "pg";
-    process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
-
     db = useDatabase();
 
     await sql`

package/src/tracing.js

@@ -119,6 +119,14 @@ function init() {
   patchConsoleLog();
 }
 
+async function forceFlush() {
+  // The "delegate" is the actual provider set by the functions-runtime package
+  const provider = opentelemetry.trace.getTracerProvider().getDelegate();
+  if (provider && provider.forceFlush) {
+    await provider.forceFlush();
+  }
+}
+
 function getTracer() {
   return opentelemetry.trace.getTracer("functions");
 }
@@ -131,5 +139,6 @@ module.exports = {
   getTracer,
   withSpan,
   init,
+  forceFlush,
   spanNameForModelAPI,
 };

package/src/tracing.test.js

@@ -33,7 +33,10 @@ test("withSpan span time", async () => {
 
   expect(spanEvents.map((e) => e.event)).toEqual(["onStart", "onEnd"]);
   const spanDuration = spanEvents.pop().span._duration.pop();
-  const waitTimeNanos = waitTimeMillis * 1000 * 1000;
+
+  // The '- 1' here is because sometimes the test fails due to the span duration
+  // being something like 99.87ms. As long as it's at least 99ms we're happy
+  const waitTimeNanos = (waitTimeMillis - 1) * 1000 * 1000;
   expect(spanDuration).toBeGreaterThan(waitTimeNanos);
 });