@teamkeel/functions-runtime 0.396.8 → 0.397.0-next.1

package/package.json

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

package/src/TimePeriod.js

@@ -0,0 +1,89 @@
+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

@@ -0,0 +1,148 @@
+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/applyWhereConditions.js

@@ -1,5 +1,6 @@
 const { sql, Kysely } = require("kysely");
 const { snakeCase } = require("./casing");
+const { TimePeriod } = require("./TimePeriod");
 
 const opMapping = {
   startsWith: { op: "like", value: (v) => `${v}%` },
@@ -16,6 +17,22 @@ const opMapping = {
   onOrAfter: { op: ">=" },
   equals: { op: sql`is not distinct from` },
   notEquals: { op: sql`is distinct from` },
+  equalsRelative: {
+    op: sql`BETWEEN`,
+    value: (v) =>
+      sql`${sql.raw(
+        TimePeriod.fromExpression(v).periodStartSQL()
+      )} AND ${sql.raw(TimePeriod.fromExpression(v).periodEndSQL())}`,
+  },
+  beforeRelative: {
+    op: "<",
+    value: (v) =>
+      sql`${sql.raw(TimePeriod.fromExpression(v).periodStartSQL())}`,
+  },
+  afterRelative: {
+    op: ">=",
+    value: (v) => sql`${sql.raw(TimePeriod.fromExpression(v).periodEndSQL())}`,
+  },
   any: {
     isArrayQuery: true,
     greaterThan: { op: ">" },

package/src/index.d.ts

@@ -29,9 +29,12 @@ export type NumberWhereCondition = {
 
 export type DateWhereCondition = {
   equals?: Date | string | null;
+  equalsRelative?: RelativeDateString | null;
   before?: Date | string | null;
+  beforeRelative?: RelativeDateString | null;
   onOrBefore?: Date | string | null;
   after?: Date | string | null;
+  afterRelative?: RelativeDateString | null;
   onOrAfter?: Date | string | null;
 };
 
@@ -46,6 +49,9 @@ export type DateQueryInput = {
 export type TimestampQueryInput = {
   before: string | null;
   after: string | null;
+  equalsRelative?: RelativeDateString | null;
+  beforeRelative?: RelativeDateString | null;
+  afterRelative?: RelativeDateString | null;
 };
 
 export type StringArrayWhereCondition = {
@@ -239,3 +245,30 @@ export type FunctionConfig = {
 export type FuncWithConfig<T> = T & {
   config: FunctionConfig;
 };
+
+type unit =
+  | "year"
+  | "years"
+  | "month"
+  | "months"
+  | "day"
+  | "days"
+  | "hour"
+  | "hours"
+  | "minute"
+  | "minutes"
+  | "second"
+  | "seconds";
+type direction = "next" | "last";
+type completed = "complete";
+type value = number;
+
+export type RelativeDateString =
+  | "now"
+  | "today"
+  | "tomorrow"
+  | "yesterday"
+  | `this ${unit}`
+  | `${direction} ${unit}`
+  | `${direction} ${value} ${unit}`
+  | `${direction} ${value} ${completed} ${unit}`;