@teamkeel/functions-runtime 0.334.0 → 0.335.0

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.334.0",
+  "version": "0.335.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
-    "test": "vitest run --reporter verbose --threads false",
+    "test": "DEBUG=true vitest run --reporter verbose --threads false",
     "format": "npx prettier --write src/**/*.js"
   },
   "keywords": [],

package/src/ModelAPI.js

@@ -3,6 +3,11 @@ const { QueryBuilder } = require("./QueryBuilder");
 const { QueryContext } = require("./QueryContext");
 const { applyWhereConditions } = require("./applyWhereConditions");
 const { applyJoins } = require("./applyJoins");
+const {
+  applyLimit,
+  applyOffset,
+  applyOrderBy,
+} = require("./applyAdditionalQueryConstraints");
 const {
   camelCaseObject,
   snakeCaseObject,
@@ -50,7 +55,7 @@ class ModelAPI {
   }
 
   async create(values) {
-    const name = spanName(this._modelName, "create");
+    const name = tracing.spanNameForModelAPI(this._modelName, "create");
     const db = getDatabase();
 
     return tracing.withSpan(name, async (span) => {
@@ -77,7 +82,7 @@ class ModelAPI {
   }
 
   async findOne(where = {}) {
-    const name = spanName(this._modelName, "findOne");
+    const name = tracing.spanNameForModelAPI(this._modelName, "findOne");
     const db = getDatabase();
 
     return tracing.withSpan(name, async (span) => {
@@ -101,21 +106,55 @@ class ModelAPI {
     });
   }
 
-  async findMany(where = {}) {
-    const name = spanName(this._modelName, "findMany");
+  async findMany(params) {
+    const name = tracing.spanNameForModelAPI(this._modelName, "findMany");
     const db = getDatabase();
+    const where = params?.where || {};
 
     return tracing.withSpan(name, async (span) => {
+      const context = new QueryContext([this._tableName], this._tableConfigMap);
+
       let builder = db
-        .selectFrom(this._tableName)
-        .distinctOn(`${this._tableName}.id`)
-        .selectAll(this._tableName);
+        .selectFrom((qb) => {
+          // We need to wrap this query as a sub query in the selectFrom because you cannot apply a different order by column when using distinct(id)
+          let builder = qb
+            .selectFrom(this._tableName)
+            .distinctOn(`${this._tableName}.id`)
+            .selectAll(this._tableName);
 
-      const context = new QueryContext([this._tableName], this._tableConfigMap);
+          builder = applyJoins(context, builder, where);
+          builder = applyWhereConditions(context, builder, where);
 
-      builder = applyJoins(context, builder, where);
-      builder = applyWhereConditions(context, builder, where);
-      const query = builder.orderBy("id");
+          builder = builder.as(this._tableName);
+
+          return builder;
+        })
+        .selectAll();
+
+      // The only constraints added to the main query are the orderBy, limit and offset as they are performed on the "outer" set
+      if (params?.limit) {
+        builder = applyLimit(context, builder, params.limit);
+      }
+
+      if (params?.offset) {
+        builder = applyOffset(context, builder, params.offset);
+      }
+
+      if (
+        params?.orderBy !== undefined &&
+        Object.keys(params?.orderBy).length > 0
+      ) {
+        builder = applyOrderBy(
+          context,
+          builder,
+          this._tableName,
+          params.orderBy
+        );
+      } else {
+        builder = builder.orderBy(`${this._tableName}.id`);
+      }
+
+      const query = builder;
 
       span.setAttribute("sql", query.compile().sql);
       const rows = await builder.execute();
@@ -124,7 +163,7 @@ class ModelAPI {
   }
 
   async update(where, values) {
-    const name = spanName(this._modelName, "update");
+    const name = tracing.spanNameForModelAPI(this._modelName, "update");
     const db = getDatabase();
 
     return tracing.withSpan(name, async (span) => {
@@ -149,7 +188,7 @@ class ModelAPI {
   }
 
   async delete(where) {
-    const name = spanName(this._modelName, "delete");
+    const name = tracing.spanNameForModelAPI(this._modelName, "delete");
     const db = getDatabase();
 
     return tracing.withSpan(name, async (span) => {
@@ -187,10 +226,6 @@ class ModelAPI {
   }
 }
 
-function spanName(modelName, action) {
-  return `Database ${modelName}.${action}`;
-}
-
 module.exports = {
   ModelAPI,
   DatabaseError,

package/src/ModelAPI.test.js

@@ -163,7 +163,7 @@ test("ModelAPI.findOne - return null if not found", async () => {
 });
 
 test("ModelAPI.findMany", async () => {
-  const jim = await personAPI.create({
+  await personAPI.create({
     name: "Jim",
     married: false,
     favouriteNumber: 10,
@@ -179,14 +179,16 @@ test("ModelAPI.findMany", async () => {
     favouriteNumber: 12,
   });
   const rows = await personAPI.findMany({
-    married: true,
+    where: {
+      married: true,
+    },
   });
   expect(rows.length).toEqual(2);
   expect(rows.map((x) => x.id).sort()).toEqual([bob.id, sally.id].sort());
 });
 
 test("ModelAPI.findMany - no where conditions", async () => {
-  const jim = await personAPI.create({
+  await personAPI.create({
     name: "Jim",
   });
   await personAPI.create({
@@ -206,8 +208,10 @@ test("ModelAPI.findMany - startsWith", async () => {
     name: "Bob",
   });
   const rows = await personAPI.findMany({
-    name: {
-      startsWith: "Ji",
+    where: {
+      name: {
+        startsWith: "Ji",
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -222,8 +226,10 @@ test("ModelAPI.findMany - endsWith", async () => {
     name: "Bob",
   });
   const rows = await personAPI.findMany({
-    name: {
-      endsWith: "im",
+    where: {
+      name: {
+        endsWith: "im",
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -241,8 +247,10 @@ test("ModelAPI.findMany - contains", async () => {
     name: "Jim",
   });
   const rows = await personAPI.findMany({
-    name: {
-      contains: "ll",
+    where: {
+      name: {
+        contains: "ll",
+      },
     },
   });
   expect(rows.length).toEqual(2);
@@ -260,8 +268,10 @@ test("ModelAPI.findMany - oneOf", async () => {
     name: "Jim",
   });
   const rows = await personAPI.findMany({
-    name: {
-      oneOf: ["Billy", "Sally"],
+    where: {
+      name: {
+        oneOf: ["Billy", "Sally"],
+      },
     },
   });
   expect(rows.length).toEqual(2);
@@ -276,8 +286,10 @@ test("ModelAPI.findMany - greaterThan", async () => {
     favouriteNumber: 2,
   });
   const rows = await personAPI.findMany({
-    favouriteNumber: {
-      greaterThan: 1,
+    where: {
+      favouriteNumber: {
+        greaterThan: 1,
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -295,8 +307,10 @@ test("ModelAPI.findMany - greaterThanOrEquals", async () => {
     favouriteNumber: 3,
   });
   const rows = await personAPI.findMany({
-    favouriteNumber: {
-      greaterThanOrEquals: 2,
+    where: {
+      favouriteNumber: {
+        greaterThanOrEquals: 2,
+      },
     },
   });
   expect(rows.length).toEqual(2);
@@ -311,8 +325,10 @@ test("ModelAPI.findMany - lessThan", async () => {
     favouriteNumber: 2,
   });
   const rows = await personAPI.findMany({
-    favouriteNumber: {
-      lessThan: 2,
+    where: {
+      favouriteNumber: {
+        lessThan: 2,
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -330,8 +346,10 @@ test("ModelAPI.findMany - lessThanOrEquals", async () => {
     favouriteNumber: 3,
   });
   const rows = await personAPI.findMany({
-    favouriteNumber: {
-      lessThanOrEquals: 2,
+    where: {
+      favouriteNumber: {
+        lessThanOrEquals: 2,
+      },
     },
   });
   expect(rows.length).toEqual(2);
@@ -346,8 +364,10 @@ test("ModelAPI.findMany - before", async () => {
     date: new Date("2022-01-02"),
   });
   const rows = await personAPI.findMany({
-    date: {
-      before: new Date("2022-01-02"),
+    where: {
+      date: {
+        before: new Date("2022-01-02"),
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -387,14 +407,156 @@ test("ModelAPI.findMany - onOrBefore", async () => {
     date: new Date("2022-01-03"),
   });
   const rows = await personAPI.findMany({
-    date: {
-      onOrBefore: new Date("2022-01-02"),
+    where: {
+      date: {
+        onOrBefore: new Date("2022-01-02"),
+      },
     },
   });
   expect(rows.length).toEqual(2);
   expect(rows.map((x) => x.id).sort()).toEqual([p.id, p2.id].sort());
 });
 
+test("ModelAPI.findMany - limit", async () => {
+  await personAPI.create({
+    id: "1",
+    name: "Jim",
+    married: false,
+    favouriteNumber: 10,
+  });
+  await personAPI.create({
+    id: "2",
+    name: "Bob",
+    married: true,
+    favouriteNumber: 11,
+  });
+  await personAPI.create({
+    id: "3",
+    name: "Sally",
+    married: true,
+    favouriteNumber: 12,
+  });
+
+  const rows = await personAPI.findMany({
+    limit: 2,
+  });
+
+  expect(rows.map((r) => r.name)).toEqual(["Jim", "Bob"]);
+});
+
+test("ModelAPI.findMany - orderBy", async () => {
+  await personAPI.create({
+    id: "1",
+    name: "Jim",
+    married: false,
+    favouriteNumber: 10,
+    date: new Date(2023, 12, 29),
+  });
+  await personAPI.create({
+    id: "2",
+    name: "Bob",
+    married: true,
+    favouriteNumber: 11,
+    date: new Date(2023, 12, 30),
+  });
+  await personAPI.create({
+    id: "3",
+    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"]);
+
+  const ascendingFavouriteNumbers = await personAPI.findMany({
+    orderBy: {
+      favouriteNumber: "asc",
+    },
+  });
+
+  expect(ascendingFavouriteNumbers.map((r) => r.name)).toEqual([
+    "Jim",
+    "Bob",
+    "Sally",
+  ]);
+
+  const descendingDates = await personAPI.findMany({
+    orderBy: {
+      date: "desc",
+    },
+  });
+
+  expect(descendingDates.map((r) => r.name)).toEqual(["Sally", "Bob", "Jim"]);
+});
+
+test("ModelAPI.findMany - offset", async () => {
+  await personAPI.create({
+    id: "1",
+    name: "Jim",
+    married: false,
+    favouriteNumber: 10,
+    date: new Date(2023, 12, 29),
+  });
+  await personAPI.create({
+    id: "2",
+    name: "Bob",
+    married: true,
+    favouriteNumber: 11,
+    date: new Date(2023, 12, 30),
+  });
+  await personAPI.create({
+    id: "3",
+    name: "Sally",
+    married: true,
+    favouriteNumber: 12,
+    date: new Date(2023, 12, 31),
+  });
+
+  const rows = await personAPI.findMany({
+    offset: 1,
+    limit: 2,
+    orderBy: {
+      name: "asc",
+    },
+  });
+
+  expect(rows.map((r) => r.name)).toEqual(["Jim", "Sally"]);
+
+  const rows2 = await personAPI.findMany({
+    offset: 2,
+    orderBy: {
+      name: "asc",
+    },
+  });
+
+  expect(rows2.map((r) => r.name)).toEqual(["Sally"]);
+
+  const rows3 = await personAPI.findMany({
+    offset: 1,
+    orderBy: {
+      name: "asc",
+    },
+    limit: 1,
+  });
+
+  expect(rows3.map((r) => r.name)).toEqual(["Jim"]);
+});
+
 test("ModelAPI.findMany - after", async () => {
   await personAPI.create({
     date: new Date("2022-01-01"),
@@ -403,8 +565,10 @@ test("ModelAPI.findMany - after", async () => {
     date: new Date("2022-01-02"),
   });
   const rows = await personAPI.findMany({
-    date: {
-      after: new Date("2022-01-01"),
+    where: {
+      date: {
+        after: new Date("2022-01-01"),
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -422,8 +586,10 @@ test("ModelAPI.findMany - onOrAfter", async () => {
     date: new Date("2022-01-03"),
   });
   const rows = await personAPI.findMany({
-    date: {
-      onOrAfter: new Date("2022-01-02"),
+    where: {
+      date: {
+        onOrAfter: new Date("2022-01-02"),
+      },
     },
   });
   expect(rows.length).toEqual(2);
@@ -438,8 +604,10 @@ test("ModelAPI.findMany - equals", async () => {
     name: "Sally",
   });
   const rows = await personAPI.findMany({
-    name: {
-      equals: "Jim",
+    where: {
+      name: {
+        equals: "Jim",
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -454,8 +622,10 @@ test("ModelAPI.findMany - notEquals", async () => {
     name: "Sally",
   });
   const rows = await personAPI.findMany({
-    name: {
-      notEquals: "Sally",
+    where: {
+      name: {
+        notEquals: "Sally",
+      },
     },
   });
   expect(rows.length).toEqual(1);
@@ -523,8 +693,10 @@ test("ModelAPI.findMany - relationships - one to many", async () => {
   });
 
   const posts = await postAPI.findMany({
-    author: {
-      name: "Jim",
+    where: {
+      author: {
+        name: "Jim",
+      },
     },
   });
   expect(posts.length).toEqual(2);
@@ -549,10 +721,12 @@ test("ModelAPI.findMany - relationships - many to one", async () => {
   });
 
   const people = await personAPI.findMany({
-    posts: {
-      title: {
-        startsWith: "My ",
-        endsWith: " Post",
+    where: {
+      posts: {
+        title: {
+          startsWith: "My ",
+          endsWith: " Post",
+        },
       },
     },
   });
@@ -666,3 +840,35 @@ test("ModelAPI.delete", async () => {
   expect(deletedId).toEqual(id);
   await expect(personAPI.findOne({ id })).resolves.toEqual(null);
 });
+
+test("ModelAPI chained findMany with offset/limit/order by", async () => {
+  await postAPI.create({
+    title: "adam",
+  });
+  await postAPI.create({
+    title: "dave",
+  });
+  const three = await postAPI.create({
+    title: "jon",
+  });
+  const four = await postAPI.create({
+    title: "jon bretman",
+  });
+
+  const results = await postAPI
+    .where({ title: { equals: "adam" } })
+    .orWhere({
+      title: { startsWith: "jon" },
+    })
+    .findMany({
+      limit: 3,
+      offset: 1,
+      orderBy: {
+        title: "asc",
+      },
+    });
+
+  // because we've offset by 1, adam should not appear in the results even though
+  // the query constraints match adam
+  expect(results).toEqual([three, four]);
+});

package/src/QueryBuilder.js

@@ -1,6 +1,13 @@
 const { applyWhereConditions } = require("./applyWhereConditions");
+const {
+  applyLimit,
+  applyOffset,
+  applyOrderBy,
+} = require("./applyAdditionalQueryConstraints");
 const { applyJoins } = require("./applyJoins");
 const { camelCaseObject, upperCamelCase } = require("./casing");
+const { getDatabase } = require("./database");
+const { QueryContext } = require("./QueryContext");
 const tracing = require("./tracing");
 
 class QueryBuilder {
@@ -36,12 +43,50 @@ class QueryBuilder {
     return new QueryBuilder(this._tableName, context, builder);
   }
 
-  async findMany() {
-    const spanName = `Database ${upperCamelCase(this._tableName)}.findMany`;
-    return tracing.withSpan(spanName, async (span) => {
-      const query = this._db.orderBy("id");
+  async findMany(params) {
+    const name = tracing.spanNameForModelAPI(this._modelName, "findMany");
+    const db = getDatabase();
+
+    return tracing.withSpan(name, async (span) => {
+      const context = new QueryContext([this._tableName], this._tableConfigMap);
+
+      let builder = db
+        .selectFrom((qb) => {
+          // this._db contains all of the where constraints and joins
+          // we want to include that in the sub query in the same way we
+          // add all of this information into the sub query in the ModelAPI's
+          // implementation of findMany
+          return this._db.as(this._tableName);
+        })
+        .selectAll();
+
+      // The only constraints added to the main query are the orderBy, limit and offset as they are performed on the "outer" set
+      if (params?.limit) {
+        builder = applyLimit(context, builder, params.limit);
+      }
+
+      if (params?.offset) {
+        builder = applyOffset(context, builder, params.offset);
+      }
+
+      if (
+        params?.orderBy !== undefined &&
+        Object.keys(params?.orderBy).length > 0
+      ) {
+        builder = applyOrderBy(
+          context,
+          builder,
+          this._tableName,
+          params.orderBy
+        );
+      } else {
+        builder = builder.orderBy(`${this._tableName}.id`);
+      }
+
+      const query = builder;
+
       span.setAttribute("sql", query.compile().sql);
-      const rows = await query.execute();
+      const rows = await builder.execute();
       return rows.map((x) => camelCaseObject(x));
     });
   }

package/src/applyAdditionalQueryConstraints.js

@@ -0,0 +1,22 @@
+const { snakeCase } = require("change-case");
+
+function applyLimit(context, qb, limit) {
+  return qb.limit(limit);
+}
+
+function applyOffset(context, qb, offset) {
+  return qb.offset(offset);
+}
+
+function applyOrderBy(context, qb, tableName, orderBy = {}) {
+  Object.entries(orderBy).forEach(([key, sortOrder]) => {
+    qb = qb.orderBy(`${tableName}.${snakeCase(key)}`, sortOrder);
+  });
+  return qb;
+}
+
+module.exports = {
+  applyLimit,
+  applyOffset,
+  applyOrderBy,
+};

package/src/database.js

@@ -63,6 +63,14 @@ function getDatabase() {
 
   db = new Kysely({
     dialect: getDialect(),
+    log(event) {
+      if ("DEBUG" in process.env) {
+        if (event.level === "query") {
+          console.log(event.query.sql);
+          console.log(event.query.parameters);
+        }
+      }
+    },
   });
 
   return db;

package/src/tracing.js

@@ -73,8 +73,13 @@ function getTracer() {
   return opentelemetry.trace.getTracer("functions");
 }
 
+function spanNameForModelAPI(modelName, action) {
+  return `Database ${modelName}.${action}`;
+}
+
 module.exports = {
   getTracer,
   withSpan,
   init,
+  spanNameForModelAPI,
 };