@teamkeel/functions-runtime 0.373.1 → 0.374.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.373.1",
+  "version": "0.374.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": [],

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/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);
 });