@teamkeel/functions-runtime 0.383.0 → 0.385.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/functions-runtime",
-  "version": "0.383.0",
+  "version": "0.385.0",
   "description": "Internal package used by @teamkeel/sdk",
   "main": "src/index.js",
   "scripts": {
@@ -27,7 +27,7 @@
     "change-case": "^4.1.2",
     "json-rpc-2.0": "^1.7.0",
     "ksuid": "^3.0.0",
-    "kysely": "^0.23.5",
+    "kysely": "^0.25.0",
     "pg": "^8.11.3",
     "traceparent": "^1.0.0"
   }

package/src/ModelAPI.js

@@ -54,7 +54,12 @@ class ModelAPI {
 
     return tracing.withSpan(name, () => {
       const db = useDatabase();
-      return create(db, this._tableName, this._tableConfigMap, values);
+      return create(
+        db,
+        this._tableName,
+        this._tableConfigMap,
+        snakeCaseObject(values)
+      );
     });
   }
 

package/src/ModelAPI.test.js

@@ -26,6 +26,8 @@ beforeEach(async () => {
   CREATE TABLE post(
     id               text PRIMARY KEY,
     title            text,
+    tags             text[],
+    rating           numeric,
     author_id        text references person(id)
   );
   CREATE TABLE author(
@@ -101,7 +103,6 @@ test("ModelAPI.create - throws if database constraint fails", async () => {
     favouriteNumber: 10,
   });
   const promise = personAPI.create({
-    id: KSUID.randomSync().string,
     id: row.id,
     name: "Jim",
     married: false,
@@ -112,6 +113,25 @@ test("ModelAPI.create - throws if database constraint fails", async () => {
   );
 });
 
+test("ModelAPI.create - arrays", async () => {
+  const person = await personAPI.create({
+    id: KSUID.randomSync().string,
+    name: "Jim",
+    married: false,
+    favouriteNumber: 10,
+  });
+
+  const row = await postAPI.create({
+    id: "id",
+    title: "My Post",
+    tags: ["tag 1", "tag 2"],
+    rating: 1.23,
+    authorId: person.id,
+  });
+  expect(row.tags).toEqual(["tag 1", "tag 2"]);
+  expect(row.rating).toEqual(1.23);
+});
+
 test("ModelAPI.findOne", async () => {
   const created = await personAPI.create({
     id: KSUID.randomSync().string,
@@ -1006,7 +1026,7 @@ describe("QueryBuilder", () => {
     expect(deletedId).toEqual(p.id);
   });
 
-  test("Model API chained delete - non existent id", async () => {
+  test("ModelAPI chained delete - non existent id", async () => {
     const fakeId = "xxx";
 
     // the error message returned from the runtime will actually be 'record not found'
@@ -1017,7 +1037,7 @@ describe("QueryBuilder", () => {
     );
   });
 
-  test("Model API chained findOne", async () => {
+  test("ModelAPI chained findOne", async () => {
     const p = await personAPI.create({
       id: KSUID.randomSync().string,
       name: "Jake",
@@ -1058,7 +1078,7 @@ describe("QueryBuilder", () => {
   //   expect(results[0].id).toEqual(p2);
   // });
 
-  test("Model API chained update", async () => {
+  test("ModelAPI chained update", async () => {
     const p1 = await postAPI.create({
       id: KSUID.randomSync().string,
       title: "adam",
@@ -1099,4 +1119,336 @@ describe("QueryBuilder", () => {
         .update({ title: "bob" })
     ).resolves.toEqual(null);
   });
+
+  test("ModelAPI.findMany - array equals", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+    const p4 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: null,
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: {
+          equals: ["Tag 1", "Tag 2"],
+        },
+      },
+    });
+
+    expect(rows.length).toEqual(1);
+    expect(rows.map((x) => x.id).sort()).toEqual([p1.id].sort());
+  });
+
+  test("ModelAPI.findMany - array equals implicit", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: ["Tag 1", "Tag 2"],
+      },
+    });
+
+    expect(rows.length).toEqual(1);
+    expect(rows.map((x) => x.id).sort()).toEqual([p1.id].sort());
+  });
+
+  test("ModelAPI.findMany - array not equals", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+    const p4 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: null,
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: {
+          notEquals: ["Tag 1", "Tag 2"],
+        },
+      },
+    });
+
+    expect(rows.length).toEqual(3);
+    expect(rows.map((x) => x.id).sort()).toEqual([p4.id, p3.id, p2.id].sort());
+  });
+
+  test("ModelAPI.findMany - array any equals", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+    const p4 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: null,
+      authorId: person.id,
+    });
+    const p5 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 3"],
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: {
+          any: {
+            equals: "Tag 2",
+          },
+        },
+      },
+    });
+
+    expect(rows.length).toEqual(2);
+    expect(rows.map((x) => x.id).sort()).toEqual([p1.id, p2.id].sort());
+  });
+
+  test("ModelAPI.findMany - array any not equals", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+    const p4 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: null,
+      authorId: person.id,
+    });
+    const p5 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 3"],
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: {
+          any: {
+            notEquals: "Tag 3",
+          },
+        },
+      },
+    });
+
+    expect(rows.length).toEqual(2);
+    expect(rows.map((x) => x.id).sort()).toEqual([p1.id, p3.id].sort());
+  });
+
+  test("ModelAPI.findMany - array all equals", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+    const p4 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: null,
+      authorId: person.id,
+    });
+    const p5 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 2"],
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: {
+          all: {
+            equals: "Tag 2",
+          },
+        },
+      },
+    });
+
+    expect(rows.length).toEqual(2);
+    expect(rows.map((x) => x.id).sort()).toEqual([p3.id, p5.id].sort());
+  });
+
+  test("ModelAPI.findMany - array all not equals", async () => {
+    const person = await personAPI.create({
+      id: KSUID.randomSync().string,
+      name: "Jake",
+      favouriteNumber: 8,
+      date: new Date("2021-12-31"),
+    });
+    const p1 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 1",
+      tags: ["Tag 1", "Tag 2"],
+      authorId: person.id,
+    });
+    const p2 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 3"],
+      authorId: person.id,
+    });
+    const p3 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: [],
+      authorId: person.id,
+    });
+    const p4 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: null,
+      authorId: person.id,
+    });
+    const p5 = await postAPI.create({
+      id: KSUID.randomSync().string,
+      title: "Post 2",
+      tags: ["Tag 2", "Tag 2"],
+      authorId: person.id,
+    });
+
+    const rows = await postAPI.findMany({
+      where: {
+        tags: {
+          all: {
+            notEquals: "Tag 2",
+          },
+        },
+      },
+    });
+
+    expect(rows.length).toEqual(2);
+    expect(rows.map((x) => x.id).sort()).toEqual([p1.id, p2.id].sort());
+  });
 });

package/src/applyWhereConditions.js

@@ -1,11 +1,11 @@
-const { sql } = require("kysely");
+const { sql, Kysely } = require("kysely");
 const { snakeCase } = require("./casing");
 
 const opMapping = {
   startsWith: { op: "like", value: (v) => `${v}%` },
   endsWith: { op: "like", value: (v) => `%${v}` },
   contains: { op: "like", value: (v) => `%${v}%` },
-  oneOf: { op: "in" },
+  oneOf: { op: "=", value: (v) => sql`ANY(${v})` },
   greaterThan: { op: ">" },
   greaterThanOrEquals: { op: ">=" },
   lessThan: { op: "<" },
@@ -16,6 +16,32 @@ const opMapping = {
   onOrAfter: { op: ">=" },
   equals: { op: sql`is not distinct from` },
   notEquals: { op: sql`is distinct from` },
+  any: {
+    isArrayQuery: true,
+    greaterThan: { op: ">" },
+    greaterThanOrEquals: { op: ">=" },
+    lessThan: { op: "<" },
+    lessThanOrEquals: { op: "<=" },
+    before: { op: "<" },
+    onOrBefore: { op: "<=" },
+    after: { op: ">" },
+    onOrAfter: { op: ">=" },
+    equals: { op: "=" },
+    notEquals: { op: "=", value: (v) => sql`NOT ${v}` },
+  },
+  all: {
+    isArrayQuery: true,
+    greaterThan: { op: ">" },
+    greaterThanOrEquals: { op: ">=" },
+    lessThan: { op: "<" },
+    lessThanOrEquals: { op: "<=" },
+    before: { op: "<" },
+    onOrBefore: { op: "<=" },
+    after: { op: ">" },
+    onOrAfter: { op: ">=" },
+    equals: { op: "=" },
+    notEquals: { op: "=", value: (v) => sql`NOT ${v}` },
+  },
 };
 
 /**
@@ -44,7 +70,7 @@ function applyWhereConditions(context, qb, where = {}) {
     const fieldName = `${context.tableAlias()}.${snakeCase(key)}`;
 
     if (Object.prototype.toString.call(v) !== "[object Object]") {
-      qb = qb.where(fieldName, "=", v);
+      qb = qb.where(fieldName, sql`is not distinct from`, sql`${v}`);
       continue;
     }
 
@@ -54,11 +80,23 @@ function applyWhereConditions(context, qb, where = {}) {
         throw new Error(`invalid where condition: ${op}`);
       }
 
-      qb = qb.where(
-        fieldName,
-        mapping.op,
-        mapping.value ? mapping.value(v[op]) : v[op]
-      );
+      if (mapping.isArrayQuery) {
+        for (const arrayOp of Object.keys(v[op])) {
+          qb = qb.where(
+            mapping[arrayOp].value
+              ? mapping[arrayOp].value(v[op][arrayOp])
+              : sql`${v[op][arrayOp]}`,
+            mapping[arrayOp].op,
+            sql`${sql(op)}(${sql.ref(fieldName)})`
+          );
+        }
+      } else {
+        qb = qb.where(
+          fieldName,
+          mapping.op,
+          mapping.value ? mapping.value(v[op]) : sql`${v[op]}`
+        );
+      }
     }
   }
 

package/src/database.js

@@ -142,6 +142,12 @@ function getDialect() {
   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
+      // 1700 = type for NUMERIC
+      pg.types.setTypeParser(1700, function (val) {
+        return parseFloat(val);
+      });
+
       return new PostgresDialect({
         pool: new InstrumentedPool({
           Client: InstrumentedClient,

package/src/index.d.ts

@@ -27,7 +27,6 @@ export type NumberWhereCondition = {
   notEquals?: number | null;
 };
 
-// Date database API
 export type DateWhereCondition = {
   equals?: Date | string | null;
   before?: Date | string | null;
@@ -36,7 +35,6 @@ export type DateWhereCondition = {
   onOrAfter?: Date | string | null;
 };
 
-// Date query input
 export type DateQueryInput = {
   equals?: string | null;
   before?: string | null;
@@ -45,12 +43,67 @@ export type DateQueryInput = {
   onOrAfter?: string | null;
 };
 
-// Timestamp query input
 export type TimestampQueryInput = {
   before: string | null;
   after: string | null;
 };
 
+export type StringArrayWhereCondition = {
+  equals?: string[] | null;
+  notEquals?: string[] | null;
+  any?: StringArrayQueryWhereCondition | null;
+  all?: StringArrayQueryWhereCondition | null;
+};
+
+export type StringArrayQueryWhereCondition = {
+  equals?: string | null;
+  notEquals?: string | null;
+};
+
+export type NumberArrayWhereCondition = {
+  equals?: number[] | null;
+  notEquals?: number[] | null;
+  any?: NumberArrayQueryWhereCondition | null;
+  all?: NumberArrayQueryWhereCondition | null;
+};
+
+export type NumberArrayQueryWhereCondition = {
+  greaterThan?: number | null;
+  greaterThanOrEquals?: number | null;
+  lessThan?: number | null;
+  lessThanOrEquals?: number | null;
+  equals?: number | null;
+  notEquals?: number | null;
+};
+
+export type BooleanArrayWhereCondition = {
+  equals?: bool[] | null;
+  notEquals?: bool[] | null;
+  any?: BooleanArrayQueryWhereCondition | null;
+  all?: BooleanArrayQueryWhereCondition | null;
+};
+
+export type BooleanArrayQueryWhereCondition = {
+  equals?: bool | null;
+  notEquals?: bool | null;
+};
+
+export type DateArrayWhereCondition = {
+  equals?: Date[] | null;
+  notEquals?: Date[] | null;
+  any?: DateArrayQueryWhereCondition | null;
+  all?: DateArrayQueryWhereCondition | null;
+};
+
+export type DateArrayQueryWhereCondition = {
+  greaterThan?: Date | null;
+  greaterThanOrEquals?: Date | null;
+  lessThan?: Date | null;
+  lessThanOrEquals?: number | null;
+  equals?: Date | null;
+  notEquals?: Date | null;
+};
+
 export type ContextAPI = {
   headers: RequestHeaders;
   response: Response;