@teamkeel/functions-runtime 0.242.1 → 0.244.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.242.1",
+  "version": "0.244.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {

package/src/ModelAPI.js

@@ -1,13 +1,41 @@
+const { getDatabase } = require("./database");
+const { QueryBuilder } = require("./QueryBuilder");
+const { QueryContext } = require("./QueryContext");
 const { applyWhereConditions } = require("./applyWhereConditions");
+const { applyJoins } = require("./applyJoins");
 const { camelCaseObject, snakeCaseObject } = require("./casing");
-const { QueryBuilder } = require("./QueryBuilder");
-const { getDatabase } = require("./database");
+
+/**
+ * RelationshipConfig is a simple representation of a model field that
+ * is a relationship. It is used by applyJoins and applyWhereConditions
+ * to build the correct query.
+ * @typedef {{
+ *  relationshipType: "belongsTo" | "hasMany",
+ *  foreignKey: string,
+ *  referencesTable: string,
+ * }} RelationshipConfig
+ *
+ * TableConfig is an object where the keys are relationship field names
+ * (which don't exist in the database) and the values are RelationshipConfig
+ * objects describing that relationship.
+ * @typedef {Object.<string, RelationshipConfig} TableConfig
+ *
+ * TableConfigMap is mapping of database table names to TableConfig objects
+ * @typedef {Object.<string, TableConfig>} TableConfigMap
+ */
 
 class ModelAPI {
-  constructor(tableName, defaultValues, db) {
-    this._tableName = tableName;
-    this._defaultValues = defaultValues;
+  /**
+   * @param {string} tableName The name of the table this API is for
+   * @param {Function} defaultValues A function that returns the default values for a row in this table
+   * @param {import("kysely").Kysely} db
+   * @param {TableConfigMap} tableConfigMap
+   */
+  constructor(tableName, defaultValues, db, tableConfigMap = {}) {
     this._db = db || getDatabase();
+    this._defaultValues = defaultValues;
+    this._tableName = tableName;
+    this._tableConfigMap = tableConfigMap;
   }
 
   async create(values) {
@@ -21,70 +49,85 @@ class ModelAPI {
       )
       .returningAll()
       .executeTakeFirst();
+
     return camelCaseObject(row);
   }
 
   async findOne(where) {
-    const row = await this._db
+    let builder = this._db
       .selectFrom(this._tableName)
-      .selectAll()
-      .where((qb) => {
-        return applyWhereConditions(qb, where);
-      })
-      .executeTakeFirst();
+      .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);
+
+    const row = await builder.executeTakeFirst();
     if (!row) {
       return null;
     }
+
     return camelCaseObject(row);
   }
 
   async findMany(where) {
-    let query = this._db.selectFrom(this._tableName).selectAll();
+    let builder = this._db
+      .selectFrom(this._tableName)
+      .distinctOn(`${this._tableName}.id`)
+      .selectAll(this._tableName);
 
-    // only apply constraints if there are keys in the where
-    if (Object.keys(where).length > 0) {
-      query = query.where((qb) => {
-        return applyWhereConditions(qb, where);
-      });
-    }
+    const context = new QueryContext([this._tableName], this._tableConfigMap);
 
-    const rows = await query.execute();
+    builder = applyJoins(context, builder, where);
+    builder = applyWhereConditions(context, builder, where);
 
+    const rows = await builder.orderBy("id").execute();
     return rows.map((x) => camelCaseObject(x));
   }
 
   async update(where, values) {
-    const row = await this._db
-      .updateTable(this._tableName)
-      .returningAll()
-      .set(snakeCaseObject(values))
-      .where((qb) => {
-        return applyWhereConditions(qb, where);
-      })
-      .executeTakeFirstOrThrow();
+    let builder = this._db.updateTable(this._tableName).returningAll();
+
+    builder = builder.set(snakeCaseObject(values));
+
+    const context = new QueryContext([this._tableName], this._tableConfigMap);
+
+    // TODO: support joins for update
+    builder = applyWhereConditions(context, builder, where);
+
+    const row = await builder.executeTakeFirstOrThrow();
     return camelCaseObject(row);
   }
 
   async delete(where) {
-    const row = await this._db
-      .deleteFrom(this._tableName)
-      .returning(["id"])
-      .where((qb) => {
-        return applyWhereConditions(qb, where);
-      })
-      .executeTakeFirstOrThrow();
+    let builder = this._db.deleteFrom(this._tableName).returning(["id"]);
+
+    const context = new QueryContext([this._tableName], this._tableConfigMap);
+
+    // TODO: support joins for delete
+    builder = applyWhereConditions(context, builder, where);
+
+    const row = await builder.executeTakeFirstOrThrow();
     return row.id;
   }
 
-  where(conditions) {
-    const q = this._db
+  where(where) {
+    let builder = this._db
       .selectFrom(this._tableName)
-      .selectAll()
-      .where((qb) => {
-        return applyWhereConditions(qb, conditions);
-      });
-    return new QueryBuilder(q);
+      .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);
+
+    return new QueryBuilder(context, builder);
   }
 }
 
-module.exports.ModelAPI = ModelAPI;
+module.exports = {
+  ModelAPI,
+};

package/src/ModelAPI.test.js

@@ -7,36 +7,72 @@ const KSUID = require("ksuid");
 process.env.DB_CONN_TYPE = "pg";
 process.env.DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
 
-let api;
+let personAPI;
+let postAPI;
 
 beforeEach(async () => {
   const db = getDatabase();
 
   await sql`
-  DROP TABLE IF EXISTS model_api_test;
-  CREATE TABLE model_api_test(
+  DROP TABLE IF EXISTS post;
+  DROP TABLE IF EXISTS person;
+  CREATE TABLE person(
       id               text PRIMARY KEY,
       name             text UNIQUE,
       married          boolean,
       favourite_number integer,
       date             timestamp
   );
+  CREATE TABLE post(
+    id               text PRIMARY KEY,
+    title            text,
+    author_id        text references person(id)
+);
   `.execute(db);
 
-  api = new ModelAPI(
-    "model_api_test",
+  const tableConfigMap = {
+    person: {
+      posts: {
+        relationshipType: "hasMany",
+        foreignKey: "author_id",
+        referencesTable: "post",
+      },
+    },
+    post: {
+      author: {
+        relationshipType: "belongsTo",
+        foreignKey: "author_id",
+        referencesTable: "person",
+      },
+    },
+  };
+
+  personAPI = new ModelAPI(
+    "person",
     () => {
       return {
         id: KSUID.randomSync().string,
         date: new Date("2022-01-01"),
       };
     },
-    db
+    db,
+    tableConfigMap
+  );
+
+  postAPI = new ModelAPI(
+    "post",
+    () => {
+      return {
+        id: KSUID.randomSync().string,
+      };
+    },
+    db,
+    tableConfigMap
   );
 });
 
 test("ModelAPI.create", async () => {
-  const row = await api.create({
+  const row = await personAPI.create({
     name: "Jim",
     married: false,
     favouriteNumber: 10,
@@ -49,58 +85,77 @@ test("ModelAPI.create", async () => {
 });
 
 test("ModelAPI.create - throws if database constraint fails", async () => {
-  const row = await api.create({
+  const row = await personAPI.create({
     name: "Jim",
     married: false,
     favouriteNumber: 10,
   });
-  const promise = api.create({
+  const promise = personAPI.create({
     id: row.id,
     name: "Jim",
     married: false,
     favouriteNumber: 10,
   });
   await expect(promise).rejects.toThrow(
-    `duplicate key value violates unique constraint "model_api_test_pkey"`
+    `duplicate key value violates unique constraint "person_pkey"`
   );
 });
 
 test("ModelAPI.findOne", async () => {
-  const created = await api.create({
+  const created = await personAPI.create({
     name: "Jim",
     married: false,
     favouriteNumber: 10,
   });
-  const row = await api.findOne({
+  const row = await personAPI.findOne({
     id: created.id,
   });
   expect(row).toEqual(created);
 });
 
+test("ModelAPI.findOne - relationships - one to many", async () => {
+  const person = await personAPI.create({
+    name: "Jim",
+    married: false,
+    favouriteNumber: 10,
+  });
+  const post = await postAPI.create({
+    title: "My Post",
+    authorId: person.id,
+  });
+  const row = await personAPI.findOne({
+    posts: {
+      id: post.id,
+    },
+  });
+  expect(row.name).toEqual("Jim");
+  expect(row.id).toEqual(person.id);
+});
+
 test("ModelAPI.findOne - return null if not found", async () => {
-  const row = await api.findOne({
+  const row = await personAPI.findOne({
     id: "doesntexist",
   });
   expect(row).toEqual(null);
 });
 
 test("ModelAPI.findMany", async () => {
-  const jim = await api.create({
+  const jim = await personAPI.create({
     name: "Jim",
     married: false,
     favouriteNumber: 10,
   });
-  const bob = await api.create({
+  const bob = await personAPI.create({
     name: "Bob",
     married: true,
     favouriteNumber: 11,
   });
-  const sally = await api.create({
+  const sally = await personAPI.create({
     name: "Sally",
     married: true,
     favouriteNumber: 12,
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     married: true,
   });
   expect(rows.length).toEqual(2);
@@ -108,26 +163,26 @@ test("ModelAPI.findMany", async () => {
 });
 
 test("ModelAPI.findMany - no where conditions", async () => {
-  const jim = await api.create({
+  const jim = await personAPI.create({
     name: "Jim",
   });
-  await api.create({
+  await personAPI.create({
     name: "Bob",
   });
 
-  const rows = await api.findMany({});
+  const rows = await personAPI.findMany({});
 
   expect(rows.length).toEqual(2);
 });
 
 test("ModelAPI.findMany - startsWith", async () => {
-  const jim = await api.create({
+  const jim = await personAPI.create({
     name: "Jim",
   });
-  await api.create({
+  await personAPI.create({
     name: "Bob",
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     name: {
       startsWith: "Ji",
     },
@@ -137,13 +192,13 @@ test("ModelAPI.findMany - startsWith", async () => {
 });
 
 test("ModelAPI.findMany - endsWith", async () => {
-  const jim = await api.create({
+  const jim = await personAPI.create({
     name: "Jim",
   });
-  await api.create({
+  await personAPI.create({
     name: "Bob",
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     name: {
       endsWith: "im",
     },
@@ -153,16 +208,16 @@ test("ModelAPI.findMany - endsWith", async () => {
 });
 
 test("ModelAPI.findMany - contains", async () => {
-  const billy = await api.create({
+  const billy = await personAPI.create({
     name: "Billy",
   });
-  const sally = await api.create({
+  const sally = await personAPI.create({
     name: "Sally",
   });
-  await api.create({
+  await personAPI.create({
     name: "Jim",
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     name: {
       contains: "ll",
     },
@@ -172,16 +227,16 @@ test("ModelAPI.findMany - contains", async () => {
 });
 
 test("ModelAPI.findMany - oneOf", async () => {
-  const billy = await api.create({
+  const billy = await personAPI.create({
     name: "Billy",
   });
-  const sally = await api.create({
+  const sally = await personAPI.create({
     name: "Sally",
   });
-  await api.create({
+  await personAPI.create({
     name: "Jim",
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     name: {
       oneOf: ["Billy", "Sally"],
     },
@@ -191,13 +246,13 @@ test("ModelAPI.findMany - oneOf", async () => {
 });
 
 test("ModelAPI.findMany - greaterThan", async () => {
-  await api.create({
+  await personAPI.create({
     favouriteNumber: 1,
   });
-  const p = await api.create({
+  const p = await personAPI.create({
     favouriteNumber: 2,
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     favouriteNumber: {
       greaterThan: 1,
     },
@@ -207,16 +262,16 @@ test("ModelAPI.findMany - greaterThan", async () => {
 });
 
 test("ModelAPI.findMany - greaterThanOrEquals", async () => {
-  await api.create({
+  await personAPI.create({
     favouriteNumber: 1,
   });
-  const p = await api.create({
+  const p = await personAPI.create({
     favouriteNumber: 2,
   });
-  const p2 = await api.create({
+  const p2 = await personAPI.create({
     favouriteNumber: 3,
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     favouriteNumber: {
       greaterThanOrEquals: 2,
     },
@@ -226,13 +281,13 @@ test("ModelAPI.findMany - greaterThanOrEquals", async () => {
 });
 
 test("ModelAPI.findMany - lessThan", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     favouriteNumber: 1,
   });
-  await api.create({
+  await personAPI.create({
     favouriteNumber: 2,
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     favouriteNumber: {
       lessThan: 2,
     },
@@ -242,16 +297,16 @@ test("ModelAPI.findMany - lessThan", async () => {
 });
 
 test("ModelAPI.findMany - lessThanOrEquals", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     favouriteNumber: 1,
   });
-  const p2 = await api.create({
+  const p2 = await personAPI.create({
     favouriteNumber: 2,
   });
-  await api.create({
+  await personAPI.create({
     favouriteNumber: 3,
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     favouriteNumber: {
       lessThanOrEquals: 2,
     },
@@ -261,13 +316,13 @@ test("ModelAPI.findMany - lessThanOrEquals", async () => {
 });
 
 test("ModelAPI.findMany - before", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     date: new Date("2022-01-01"),
   });
-  await api.create({
+  await personAPI.create({
     date: new Date("2022-01-02"),
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     date: {
       before: new Date("2022-01-02"),
     },
@@ -277,16 +332,16 @@ test("ModelAPI.findMany - before", async () => {
 });
 
 test("ModelAPI.findMany - onOrBefore", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     date: new Date("2022-01-01"),
   });
-  const p2 = await api.create({
+  const p2 = await personAPI.create({
     date: new Date("2022-01-02"),
   });
-  await api.create({
+  await personAPI.create({
     date: new Date("2022-01-03"),
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     date: {
       onOrBefore: new Date("2022-01-02"),
     },
@@ -296,13 +351,13 @@ test("ModelAPI.findMany - onOrBefore", async () => {
 });
 
 test("ModelAPI.findMany - after", async () => {
-  await api.create({
+  await personAPI.create({
     date: new Date("2022-01-01"),
   });
-  const p = await api.create({
+  const p = await personAPI.create({
     date: new Date("2022-01-02"),
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     date: {
       after: new Date("2022-01-01"),
     },
@@ -312,16 +367,16 @@ test("ModelAPI.findMany - after", async () => {
 });
 
 test("ModelAPI.findMany - onOrAfter", async () => {
-  await api.create({
+  await personAPI.create({
     date: new Date("2022-01-01"),
   });
-  const p = await api.create({
+  const p = await personAPI.create({
     date: new Date("2022-01-02"),
   });
-  const p2 = await api.create({
+  const p2 = await personAPI.create({
     date: new Date("2022-01-03"),
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     date: {
       onOrAfter: new Date("2022-01-02"),
     },
@@ -331,13 +386,13 @@ test("ModelAPI.findMany - onOrAfter", async () => {
 });
 
 test("ModelAPI.findMany - equals", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     name: "Jim",
   });
-  await api.create({
+  await personAPI.create({
     name: "Sally",
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     name: {
       equals: "Jim",
     },
@@ -347,13 +402,13 @@ test("ModelAPI.findMany - equals", async () => {
 });
 
 test("ModelAPI.findMany - notEquals", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     name: "Jim",
   });
-  await api.create({
+  await personAPI.create({
     name: "Sally",
   });
-  const rows = await api.findMany({
+  const rows = await personAPI.findMany({
     name: {
       notEquals: "Sally",
     },
@@ -363,23 +418,23 @@ test("ModelAPI.findMany - notEquals", async () => {
 });
 
 test("ModelAPI.findMany - complex query", async () => {
-  const p = await api.create({
+  const p = await personAPI.create({
     name: "Jake",
     favouriteNumber: 8,
     date: new Date("2021-12-31"),
   });
-  await api.create({
+  await personAPI.create({
     name: "Jane",
     favouriteNumber: 12,
     date: new Date("2022-01-11"),
   });
-  const p2 = await api.create({
+  const p2 = await personAPI.create({
     name: "Billy",
     favouriteNumber: 16,
     date: new Date("2022-01-05"),
   });
 
-  const rows = await api
+  const rows = await personAPI
     // Will match Jake
     .where({
       name: {
@@ -402,18 +457,113 @@ test("ModelAPI.findMany - complex query", async () => {
   expect(rows.map((x) => x.id).sort()).toEqual([p.id, p2.id].sort());
 });
 
+test("ModelAPI.findMany - relationships - one to many", async () => {
+  const person = await personAPI.create({
+    name: "Jim",
+  });
+  const person2 = await personAPI.create({
+    name: "Bob",
+  });
+  const post1 = await postAPI.create({
+    title: "My First Post",
+    authorId: person.id,
+  });
+  const post2 = await postAPI.create({
+    title: "My Second Post",
+    authorId: person.id,
+  });
+  await postAPI.create({
+    title: "My Third Post",
+    authorId: person2.id,
+  });
+
+  const posts = await postAPI.findMany({
+    author: {
+      name: "Jim",
+    },
+  });
+  expect(posts.length).toEqual(2);
+  expect(posts.map((x) => x.id).sort()).toEqual([post1.id, post2.id].sort());
+});
+
+test("ModelAPI.findMany - relationships - many to one", async () => {
+  const person = await personAPI.create({
+    name: "Jim",
+  });
+  await postAPI.create({
+    title: "My First Post",
+    authorId: person.id,
+  });
+  await postAPI.create({
+    title: "My Second Post",
+    authorId: person.id,
+  });
+  await postAPI.create({
+    title: "My Second Post",
+    authorId: person.id,
+  });
+
+  const people = await personAPI.findMany({
+    posts: {
+      title: {
+        startsWith: "My ",
+        endsWith: " Post",
+      },
+    },
+  });
+
+  // This tests that many to one joins work for findMany() but also
+  // that the same row is not returned more than once e.g. Jim has
+  // three posts but should only be returned once
+  expect(people.length).toEqual(1);
+  expect(people[0].id).toEqual(person.id);
+});
+
+test("ModelAPI.findMany - relationships - duplicate joins handled", async () => {
+  const person = await personAPI.create({
+    name: "Jim",
+  });
+  const person2 = await personAPI.create({
+    name: "Bob",
+  });
+  const post1 = await postAPI.create({
+    title: "My First Post",
+    authorId: person.id,
+  });
+  const post2 = await postAPI.create({
+    title: "My Second Post",
+    authorId: person2.id,
+  });
+
+  const posts = await postAPI
+    .where({
+      author: {
+        name: "Jim",
+      },
+    })
+    .orWhere({
+      author: {
+        name: "Bob",
+      },
+    })
+    .findMany();
+
+  expect(posts.length).toEqual(2);
+  expect(posts.map((x) => x.id).sort()).toEqual([post1.id, post2.id].sort());
+});
+
 test("ModelAPI.update", async () => {
-  let jim = await api.create({
+  let jim = await personAPI.create({
     name: "Jim",
     married: false,
     favouriteNumber: 10,
   });
-  let bob = await api.create({
+  let bob = await personAPI.create({
     name: "Bob",
     married: false,
     favouriteNumber: 11,
   });
-  jim = await api.update(
+  jim = await personAPI.update(
     {
       id: jim.id,
     },
@@ -424,12 +574,12 @@ test("ModelAPI.update", async () => {
   expect(jim.married).toEqual(true);
   expect(jim.name).toEqual("Jim");
 
-  bob = await api.findOne({ id: bob.id });
+  bob = await personAPI.findOne({ id: bob.id });
   expect(bob.married).toEqual(false);
 });
 
 test("ModelAPI.update - throws if not found", async () => {
-  const result = api.update(
+  const result = personAPI.update(
     {
       id: "doesntexist",
     },
@@ -441,14 +591,14 @@ test("ModelAPI.update - throws if not found", async () => {
 });
 
 test("ModelAPI.delete", async () => {
-  const jim = await api.create({
+  const jim = await personAPI.create({
     name: "Jim",
   });
   const id = jim.id;
-  const deletedId = await api.delete({
+  const deletedId = await personAPI.delete({
     name: "Jim",
   });
 
   expect(deletedId).toEqual(id);
-  await expect(api.findOne({ id })).resolves.toEqual(null);
+  await expect(personAPI.findOne({ id })).resolves.toEqual(null);
 });

package/src/QueryBuilder.js

@@ -1,27 +1,40 @@
 const { applyWhereConditions } = require("./applyWhereConditions");
+const { applyJoins } = require("./applyJoins");
 const { camelCaseObject } = require("./casing");
 
 class QueryBuilder {
-  constructor(db) {
+  /**
+   * @param {import("./QueryContext").QueryContext} context
+   * @param {import("kysely").Kysely} db
+   */
+  constructor(context, db) {
+    this._context = context;
     this._db = db;
   }
 
-  where(conditions) {
-    const q = this._db.where((qb) => {
-      return applyWhereConditions(qb, conditions);
-    });
-    return new QueryBuilder(q);
+  where(where) {
+    const context = this._context.clone();
+
+    let builder = applyJoins(context, this._db, where);
+    builder = applyWhereConditions(context, builder, where);
+
+    return new QueryBuilder(context, builder);
   }
 
-  orWhere(conditions) {
-    const q = this._db.orWhere((qb) => {
-      return applyWhereConditions(qb, conditions);
+  orWhere(where) {
+    const context = this._context.clone();
+
+    let builder = applyJoins(context, this._db, where);
+
+    builder = builder.orWhere((qb) => {
+      return applyWhereConditions(context, qb, where);
     });
-    return new QueryBuilder(q);
+
+    return new QueryBuilder(context, builder);
   }
 
   async findMany() {
-    const rows = await this._db.execute();
+    const rows = await this._db.orderBy("id").execute();
     return rows.map((x) => camelCaseObject(x));
   }
 }

package/src/QueryContext.js

@@ -0,0 +1,90 @@
+/**
+ * QueryContext is used to store state about the current query, for example
+ * which joins have already been applied. It is used by applyJoins and
+ * applyWhereConditions to generate consistent table aliases for joins.
+ *
+ * This class has the concept of a "table path". This is just a list of tables, starting
+ * with some "root" table and ending with the table we're currently joining to. So
+ * for example if we started with a "product" table and joined from there to "order_item"
+ * and then to "order" and then to "customer" the table path would be:
+ *   ["product", "order_item", "order", "customer"]
+ * At this point the "current" table is "customer" and it's alias would be:
+ *   "product$order_item$order$customer"
+ */
+class QueryContext {
+  /**
+   * @param {string[]} tablePath This is the path from the "root" table to the "current table".
+   * @param {import("./ModelAPI").TableConfigMap} tableConfigMap
+   * @param {string[]} joins
+   */
+  constructor(tablePath, tableConfigMap, joins = []) {
+    this._tablePath = tablePath;
+    this._tableConfigMap = tableConfigMap;
+    this._joins = joins;
+  }
+
+  clone() {
+    return new QueryContext([...this._tablePath], this._tableConfigMap, [
+      ...this._joins,
+    ]);
+  }
+
+  /**
+   * Returns true if, given the current table path, a join to the given
+   * table has already been added.
+   * @param {string} table
+   * @returns {boolean}
+   */
+  hasJoin(table) {
+    const alias = joinAlias([...this._tablePath, table]);
+    return this._joins.includes(alias);
+  }
+
+  /**
+   * Adds table to the QueryContext's path and registers the join,
+   * calls fn, then pops the table off the path.
+   * @param {string} table
+   * @param {Function} fn
+   */
+  withJoin(table, fn) {
+    this._tablePath.push(table);
+    this._joins.push(this.tableAlias());
+
+    fn();
+
+    // Don't change the _joins list, we want to remember those
+    this._tablePath.pop();
+  }
+
+  /**
+   * Returns the alias that will be used for the current table
+   * @returns {string}
+   */
+  tableAlias() {
+    return joinAlias(this._tablePath);
+  }
+
+  /**
+   * Returns the current table name
+   * @returns {string}
+   */
+  tableName() {
+    return this._tablePath[this._tablePath.length - 1];
+  }
+
+  /**
+   * Return the TableConfig for the current table
+   * @returns {import("./ModelAPI").TableConfig | undefined}
+   */
+  tableConfig() {
+    return this._tableConfigMap[this.tableName()];
+  }
+}
+
+function joinAlias(tablePath) {
+  return tablePath.join("$");
+}
+
+module.exports = {
+  QueryContext,
+};

package/src/applyJoins.js

@@ -0,0 +1,65 @@
+/**
+ * Adds the joins required by the where conditions to the given
+ * Kysely instance and returns the resulting new Kysely instance.
+ * @param {import("./QueryContext").QueryContext} context
+ * @param {import("kysely").Kysely} qb
+ * @param {Object} where
+ * @returns {import("kysely").Kysely}
+ */
+function applyJoins(context, qb, where) {
+  const conf = context.tableConfig();
+  if (!conf) {
+    return qb;
+  }
+
+  const srcTableName = context.tableName();
+
+  for (const key of Object.keys(where)) {
+    const rel = conf[key];
+    if (!rel) {
+      continue;
+    }
+
+    const targetTable = rel.referencesTable;
+
+    if (context.hasJoin(targetTable)) {
+      continue;
+    }
+
+    context.withJoin(targetTable, () => {
+      switch (rel.relationshipType) {
+        case "hasMany":
+          // For hasMany the primary key is on the source table
+          // and the foreign key is on the target table
+          qb = qb.innerJoin(
+            `${targetTable} as ${context.tableAlias()}`,
+            `${srcTableName}.id`,
+            `${context.tableAlias()}.${rel.foreignKey}`
+          );
+          break;
+
+        case "belongsTo":
+          // For belongsTo the primary key is on the target table
+          // and the foreign key is on the source table
+          qb = qb.innerJoin(
+            `${targetTable} as ${context.tableAlias()}`,
+            `${srcTableName}.${rel.foreignKey}`,
+            `${context.tableAlias()}.id`
+          );
+          break;
+        default:
+          throw new Error(`unknown relationshipType: ${rel.relationshipType}`);
+      }
+
+      // Keep traversing through the where conditions to see if
+      // more joins need to be applied
+      qb = applyJoins(context, qb, where[key]);
+    });
+  }
+
+  return qb;
+}
+
+module.exports = {
+  applyJoins,
+};

package/src/applyWhereConditions.js

@@ -1,5 +1,5 @@
-const { snakeCase } = require("./casing");
 const { sql } = require("kysely");
+const { snakeCase } = require("./casing");
 
 const opMapping = {
   startsWith: { op: "like", value: (v) => `${v}%` },
@@ -18,10 +18,30 @@ const opMapping = {
   notEquals: { op: sql`is distinct from` },
 };
 
-function applyWhereConditions(qb, where) {
+/**
+ * Applies the given where conditions to the provided Kysely
+ * instance and returns the resulting new Kysely instance.
+ * @param {import("./QueryContext").QueryContext} context
+ * @param {import("kysely").Kysely} qb
+ * @param {Object} where
+ * @returns {import("kysely").Kysely}
+ */
+function applyWhereConditions(context, qb, where) {
+  const conf = context.tableConfig();
+
   for (const key of Object.keys(where)) {
     const v = where[key];
-    const fieldName = snakeCase(key);
+
+    // Handle nested where conditions e.g. using a join table
+    if (conf && conf[key]) {
+      const rel = conf[key];
+      context.withJoin(rel.referencesTable, () => {
+        qb = applyWhereConditions(context, qb, v);
+      });
+      continue;
+    }
+
+    const fieldName = `${context.tableAlias()}.${snakeCase(key)}`;
 
     if (Object.prototype.toString.call(v) !== "[object Object]") {
       qb = qb.where(fieldName, "=", v);
@@ -45,4 +65,6 @@ function applyWhereConditions(qb, where) {
   return qb;
 }
 
-module.exports.applyWhereConditions = applyWhereConditions;
+module.exports = {
+  applyWhereConditions,
+};