@teamkeel/functions-runtime 0.411.0 → 0.412.0-next.1

package/src/QueryBuilder.js

@@ -1,184 +0,0 @@
-const { applyWhereConditions } = require("./applyWhereConditions");
-const {
-  applyLimit,
-  applyOffset,
-  applyOrderBy,
-} = require("./applyAdditionalQueryConstraints");
-const { applyJoins } = require("./applyJoins");
-const {
-  camelCaseObject,
-  snakeCaseObject,
-  upperCamelCase,
-} = require("./casing");
-const { useDatabase } = require("./database");
-const { transformRichDataTypes } = require("./parsing");
-const { QueryContext } = require("./QueryContext");
-const tracing = require("./tracing");
-const { DatabaseError } = require("./errors");
-
-class QueryBuilder {
-  /**
-   * @param {string} tableName
-   * @param {import("./QueryContext").QueryContext} context
-   * @param {import("kysely").Kysely} db
-   */
-  constructor(tableName, context, db) {
-    this._tableName = tableName;
-    this._context = context;
-    this._db = db;
-    this._modelName = upperCamelCase(this._tableName);
-  }
-
-  where(where) {
-    const context = this._context.clone();
-
-    let builder = applyJoins(context, this._db, where);
-    builder = applyWhereConditions(context, builder, where);
-
-    return new QueryBuilder(this._tableName, context, builder);
-  }
-
-  sql() {
-    return this._db.compile().sql;
-  }
-
-  async update(values) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "update");
-    const db = useDatabase();
-
-    return tracing.withSpan(name, async (span) => {
-      // we build a sub-query to add to the WHERE id IN (XXX) containing all of the
-      // wheres added in previous .where() chains.
-      const sub = this._db.clearSelect().select("id");
-
-      const query = db
-        .updateTable(this._tableName)
-        .set(snakeCaseObject(values))
-        .returningAll()
-        .where("id", "in", sub);
-
-      try {
-        const result = await query.execute();
-        const numUpdatedRows = result.length;
-
-        // the double (==) is important because we are comparing bigint to int
-        if (numUpdatedRows == 0) {
-          return null;
-        }
-
-        if (numUpdatedRows > 1) {
-          throw new DatabaseError(
-            new Error(
-              "more than one row matched update constraints - only unique fields should be used when updating."
-            )
-          );
-        }
-
-        return transformRichDataTypes(camelCaseObject(result[0]));
-      } catch (e) {
-        throw new DatabaseError(e);
-      }
-    });
-  }
-
-  async delete() {
-    const name = tracing.spanNameForModelAPI(this._modelName, "delete");
-    const db = useDatabase();
-
-    return tracing.withSpan(name, async (span) => {
-      // the original query selects the distinct id + the model.* so we need to clear
-      const sub = this._db.clearSelect().select("id");
-      let builder = db.deleteFrom(this._tableName).where("id", "in", sub);
-
-      const query = builder.returning(["id"]);
-
-      // final query looks something like:
-      // delete from "person" where "id" in (select distinct on ("person"."id") "id" from "person" where "person"."id" = $1) returning "id"
-
-      span.setAttribute("sql", query.compile().sql);
-
-      try {
-        const row = await query.executeTakeFirstOrThrow();
-        return row.id;
-      } catch (e) {
-        throw new DatabaseError(e);
-      }
-    });
-  }
-
-  async findOne() {
-    const name = tracing.spanNameForModelAPI(this._modelName, "findOne");
-    const db = useDatabase();
-
-    return tracing.withSpan(name, async (span) => {
-      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 findOne
-          return this._db.as(this._tableName);
-        })
-        .selectAll();
-
-      span.setAttribute("sql", builder.compile().sql);
-
-      const row = await builder.executeTakeFirst();
-      if (!row) {
-        return null;
-      }
-
-      return transformRichDataTypes(camelCaseObject(row));
-    });
-  }
-
-  async findMany(params) {
-    const name = tracing.spanNameForModelAPI(this._modelName, "findMany");
-    const db = useDatabase();
-
-    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 builder.execute();
-      return rows.map((x) => transformRichDataTypes(camelCaseObject(x)));
-    });
-  }
-}
-
-module.exports.QueryBuilder = QueryBuilder;

package/src/QueryContext.js

@@ -1,90 +0,0 @@
-/**
- * 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/RequestHeaders.js

@@ -1,21 +0,0 @@
-class RequestHeaders {
-  /**
-   * @param {{Object.<string, string>}} requestHeaders Map of request headers submitted from the client
-   */
-
-  constructor(requestHeaders) {
-    this._headers = new Headers(requestHeaders);
-  }
-
-  get(key) {
-    return this._headers.get(key);
-  }
-
-  has(key) {
-    return this._headers.has(key);
-  }
-}
-
-module.exports = {
-  RequestHeaders,
-};

package/src/TimePeriod.js

@@ -1,89 +0,0 @@
-class TimePeriod {
-  constructor(period = "", value = 0, offset = 0, complete = false) {
-    this.period = period;
-    this.value = value;
-    this.offset = offset;
-    this.complete = complete;
-  }
-
-  static fromExpression(expression) {
-    // Regex pattern
-    const pattern =
-      /^(this|next|last)?\s*(\d+)?\s*(complete)?\s*(second|minute|hour|day|week|month|year|seconds|minutes|hours|days|weeks|months|years)?$/i;
-
-    const shorthandPattern = /^(now|today|tomorrow|yesterday)$/i;
-
-    const shorthandMatch = shorthandPattern.exec(expression.trim());
-    if (shorthandMatch) {
-      const shorthand = shorthandMatch[1].toLowerCase();
-      switch (shorthand) {
-        case "now":
-          return new TimePeriod();
-        case "today":
-          return TimePeriod.fromExpression("this day");
-        case "tomorrow":
-          return TimePeriod.fromExpression("next complete day");
-        case "yesterday":
-          return TimePeriod.fromExpression("last complete day");
-      }
-    }
-
-    const match = pattern.exec(expression.trim());
-    if (!match) {
-      throw new Error("Invalid time period expression");
-    }
-
-    const [, direction, rawValue, isComplete, rawPeriod] = match;
-
-    let period = rawPeriod ? rawPeriod.toLowerCase().replace(/s$/, "") : "";
-    let value = rawValue ? parseInt(rawValue, 10) : 1;
-    let complete = Boolean(isComplete);
-    let offset = 0;
-
-    switch (direction?.toLowerCase()) {
-      case "this":
-        offset = 0;
-        complete = true;
-        break;
-      case "next":
-        offset = complete ? 1 : 0;
-        break;
-      case "last":
-        offset = -value;
-        break;
-      default:
-        throw new Error(
-          "Time period expression must start with this, next, or last"
-        );
-    }
-
-    return new TimePeriod(period, value, offset, complete);
-  }
-
-  periodStartSQL() {
-    let sql = "NOW()";
-    if (this.offset !== 0) {
-      sql = `${sql} + INTERVAL '${this.offset} ${this.period}'`;
-    }
-
-    if (this.complete) {
-      sql = `DATE_TRUNC('${this.period}', ${sql})`;
-    } else {
-      sql = `(${sql})`;
-    }
-
-    return sql;
-  }
-
-  periodEndSQL() {
-    let sql = this.periodStartSQL();
-    if (this.value != 0) {
-      sql = `(${sql} + INTERVAL '${this.value} ${this.period}')`;
-    }
-    return sql;
-  }
-}
-
-module.exports = {
-  TimePeriod,
-};

package/src/TimePeriod.test.js

@@ -1,148 +0,0 @@
-import { test, expect } from "vitest";
-const { TimePeriod } = require("./TimePeriod");
-
-test("shorthands test", async () => {
-  const today = TimePeriod.fromExpression("today");
-  expect(today).toEqual({
-    period: "day",
-    value: 1,
-    complete: true,
-    offset: 0,
-  });
-
-  const tomorrow = TimePeriod.fromExpression("tomorrow");
-  expect(tomorrow).toEqual({
-    period: "day",
-    value: 1,
-    complete: true,
-    offset: 1,
-  });
-
-  const yesterday = TimePeriod.fromExpression("yesterday");
-  expect(yesterday).toEqual({
-    period: "day",
-    value: 1,
-    complete: true,
-    offset: -1,
-  });
-
-  const now = TimePeriod.fromExpression("now");
-  expect(now).toEqual({
-    period: "",
-    value: 0,
-    complete: false,
-    offset: 0,
-  });
-  expect(now.periodStartSQL()).toEqual("(NOW())");
-  expect(now.periodEndSQL()).toEqual("(NOW())");
-});
-
-test("next test", async () => {
-  let period = TimePeriod.fromExpression("next day");
-  expect(period).toEqual({
-    period: "day",
-    value: 1,
-    complete: false,
-    offset: 0,
-  });
-
-  period = TimePeriod.fromExpression("next complete day");
-  expect(period).toEqual({
-    period: "day",
-    value: 1,
-    complete: true,
-    offset: 1,
-  });
-
-  period = TimePeriod.fromExpression("next 5 complete day");
-  expect(period).toEqual({
-    period: "day",
-    value: 5,
-    complete: true,
-    offset: 1,
-  });
-
-  period = TimePeriod.fromExpression("next 5 months");
-  expect(period).toEqual({
-    period: "month",
-    value: 5,
-    complete: false,
-    offset: 0,
-  });
-
-  period = TimePeriod.fromExpression("next 2 complete years");
-  expect(period).toEqual({
-    period: "year",
-    value: 2,
-    complete: true,
-    offset: 1,
-  });
-});
-
-test("last test", async () => {
-  let period = TimePeriod.fromExpression("last day");
-  expect(period).toEqual({
-    period: "day",
-    value: 1,
-    complete: false,
-    offset: -1,
-  });
-
-  period = TimePeriod.fromExpression("last complete day");
-  expect(period).toEqual({
-    period: "day",
-    value: 1,
-    complete: true,
-    offset: -1,
-  });
-
-  period = TimePeriod.fromExpression("last 5 complete day");
-  expect(period).toEqual({
-    period: "day",
-    value: 5,
-    complete: true,
-    offset: -5,
-  });
-
-  period = TimePeriod.fromExpression("last 5 months");
-  expect(period).toEqual({
-    period: "month",
-    value: 5,
-    complete: false,
-    offset: -5,
-  });
-
-  period = TimePeriod.fromExpression("last 2 complete years");
-  expect(period).toEqual({
-    period: "year",
-    value: 2,
-    complete: true,
-    offset: -2,
-  });
-
-  period = TimePeriod.fromExpression("last complete year");
-  expect(period).toEqual({
-    period: "year",
-    value: 1,
-    complete: true,
-    offset: -1,
-  });
-});
-
-test("errors test", async () => {
-  expect(() => TimePeriod.fromExpression("last test day")).toThrowError(
-    "Invalid time period expression"
-  );
-  expect(() => TimePeriod.fromExpression("today now")).toThrowError(
-    "Invalid time period expression"
-  );
-  expect(() => TimePeriod.fromExpression("last -5 days")).toThrowError(
-    "Invalid time period expression"
-  );
-  expect(() => TimePeriod.fromExpression("5 mont")).toThrowError(
-    "Invalid time period expression"
-  );
-  expect(() => TimePeriod.fromExpression("5 days")).toThrowError(
-    "Time period expression must start with this, next, or last"
-  );
-});

package/src/applyAdditionalQueryConstraints.js

@@ -1,22 +0,0 @@
-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.toLowerCase());
-  });
-  return qb;
-}
-
-module.exports = {
-  applyLimit,
-  applyOffset,
-  applyOrderBy,
-};

package/src/applyJoins.js

@@ -1,67 +0,0 @@
-const { snakeCase } = require("./casing");
-
-/**
- * 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 srcTable = context.tableAlias();
-
-  for (const key of Object.keys(where)) {
-    const rel = conf[snakeCase(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()}`,
-            `${srcTable}.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()}`,
-            `${srcTable}.${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,
-};