@teamkeel/functions-runtime 0.396.8 → 0.397.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.396.8",
+  "version": "0.397.1",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
@@ -35,5 +35,6 @@
     "pg": "^8.11.3",
     "traceparent": "^1.0.0",
     "ws": "^8.17.1"
-  }
+  },
+  "packageManager": "pnpm@9.12.3+sha512.cce0f9de9c5a7c95bef944169cc5dfe8741abfb145078c0d508b868056848a87c81e626246cb60967cbd7fd29a6c062ef73ff840d96b3c86c40ac92cf4a813ee"
 }

package/src/File.js

@@ -5,7 +5,7 @@ const {
 } = require("@aws-sdk/client-s3");
 const { fromEnv } = require("@aws-sdk/credential-providers");
 const { getSignedUrl } = require("@aws-sdk/s3-request-presigner");
-const { createDatabaseClient } = require("./database");
+const { useDatabase } = require("./database");
 const { DatabaseError } = require("./errors");
 const KSUID = require("ksuid");
 
@@ -126,7 +126,7 @@ class File extends InlineFile {
     }
 
     // default to db storage
-    const db = createDatabaseClient();
+    const db = useDatabase();
 
     try {
       let query = db
@@ -138,8 +138,6 @@ class File extends InlineFile {
       return row.data;
     } catch (e) {
       throw new DatabaseError(e);
-    } finally {
-      await db.destroy();
     }
   }
 
@@ -241,7 +239,7 @@ async function storeFile(contents, key, filename, contentType, expires) {
       throw error;
     }
   } else {
-    const db = createDatabaseClient();
+    const db = useDatabase();
 
     try {
       let query = db
@@ -267,8 +265,6 @@ async function storeFile(contents, key, filename, contentType, expires) {
       await query.execute();
     } catch (e) {
       throw new DatabaseError(e);
-    } finally {
-      await db.destroy();
     }
   }
 }

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/database.js

@@ -5,6 +5,7 @@ const { AuditContextPlugin } = require("./auditing");
 const pg = require("pg");
 const { withSpan } = require("./tracing");
 const ws = require("ws");
+const fs = require("node:fs");
 
 // withDatabase is responsible for setting the correct database client in our AsyncLocalStorage
 // so that the the code in a custom function uses the correct client.
@@ -65,9 +66,9 @@ function useDatabase() {
 // createDatabaseClient will return a brand new instance of Kysely. Every instance of Kysely
 // represents an individual connection to the database.
 // not to be exported externally from our sdk - consumers should use useDatabase
-function createDatabaseClient() {
+function createDatabaseClient({ connString } = {}) {
   const db = new Kysely({
-    dialect: getDialect(),
+    dialect: getDialect(connString),
     plugins: [
       // ensures that the audit context data is written to Postgres configuration parameters
       new AuditContextPlugin(),
@@ -139,8 +140,8 @@ class InstrumentedClient extends pg.Client {
   }
 }
 
-function getDialect() {
-  const dbConnType = process.env["KEEL_DB_CONN_TYPE"];
+function getDialect(connString) {
+  const dbConnType = process.env.KEEL_DB_CONN_TYPE;
   switch (dbConnType) {
     case "pg":
       // Adding a custom type parser for numeric fields: see https://kysely.dev/docs/recipes/data-types#configuring-runtime-javascript-types
@@ -165,7 +166,14 @@ function getDialect() {
           // time is takes for a lambda to freeze (which is not a constant, but could be as short as several minutes,
           // https://www.pluralsight.com/resources/blog/cloud/how-long-does-aws-lambda-keep-your-idle-functions-around-before-a-cold-start)
           idleTimeoutMillis: 50000,
-          connectionString: mustEnv("KEEL_DB_CONN"),
+
+          // If connString is not passed fall back to reading from env var
+          connectionString: connString || process.env.KEEL_DB_CONN,
+
+          // Allow the setting of a cert (.pem) file. RDS requires this to enforce SSL.
+          ...(process.env.KEEL_DB_CERT
+            ? { ssl: { ca: fs.readFileSync(process.env.KEEL_DB_CERT) } }
+            : undefined),
         }),
       });
     case "neon":
@@ -178,7 +186,8 @@ function getDialect() {
       neonserverless.neonConfig.webSocketConstructor = ws;
 
       const pool = new InstrumentedNeonServerlessPool({
-        connectionString: mustEnv("KEEL_DB_CONN"),
+        // If connString is not passed fall back to reading from env var
+        connectionString: connString || process.env.KEEL_DB_CONN,
       });
 
       pool.on("connect", (client) => {
@@ -196,7 +205,7 @@ function getDialect() {
           return withSpan(spanName, function (span) {
             if (sqlAttribute) {
               span.setAttribute("sql", args[0]);
-              span.setAttribute("dialect", process.env["KEEL_DB_CONN_TYPE"]);
+              span.setAttribute("dialect", dbConnType);
             }
             return originalQuery.apply(client, args);
           });
@@ -211,14 +220,6 @@ function getDialect() {
   }
 }
 
-function mustEnv(key) {
-  const v = process.env[key];
-  if (!v) {
-    throw new Error(`expected environment variable ${key} to be set`);
-  }
-  return v;
-}
-
 module.exports = {
   createDatabaseClient,
   useDatabase,

package/src/handleJob.js

@@ -53,7 +53,9 @@ async function handleJob(request, config) {
             ? true
             : null;
 
-        db = createDatabaseClient();
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN,
+        });
         const jobFunction = jobs[request.method];
         const actionType = PROTO_ACTION_TYPES.JOB;
 

package/src/handleRequest.js

@@ -64,7 +64,9 @@ async function handleRequest(request, config) {
             ? true
             : null;
 
-        db = createDatabaseClient();
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN,
+        });
         const customFunction = functions[request.method];
         const actionType = actionTypes[request.method];
 
@@ -87,7 +89,9 @@ async function handleRequest(request, config) {
             // Return the custom function to the containing tryExecuteFunction block
             // Once the custom function is called, tryExecuteFunction will check the schema's permission rules to see if it can continue committing
             // the transaction to the db. If a permission rule is violated, any changes made inside the transaction are rolled back.
-            return customFunction(ctx, inputs);
+            const result = await customFunction(ctx, inputs);
+
+            return parseOutputs(result);
           }
         );
 
@@ -100,9 +104,7 @@ async function handleRequest(request, config) {
           return errorToJSONRPCResponse(request, result);
         }
 
-        const parsed = await parseOutputs(result);
-
-        const response = createJSONRPCSuccessResponse(request.id, parsed);
+        const response = createJSONRPCSuccessResponse(request.id, result);
 
         const responseHeaders = {};
         for (const pair of headers.entries()) {

package/src/handleSubscriber.js

@@ -48,7 +48,9 @@ async function handleSubscriber(request, config) {
           meta: request.meta,
         });
 
-        db = createDatabaseClient();
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN,
+        });
         const subscriberFunction = subscribers[request.method];
         const actionType = PROTO_ACTION_TYPES.SUBSCRIBER;
 

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}`;