@teamkeel/functions-runtime 0.412.0-next.2 → 0.412.0

package/src/applyWhereConditions.js

@@ -0,0 +1,124 @@
+const { sql, Kysely } = require("kysely");
+const { snakeCase } = require("./casing");
+const { TimePeriod } = require("./TimePeriod");
+
+const opMapping = {
+  startsWith: { op: "like", value: (v) => `${v}%` },
+  endsWith: { op: "like", value: (v) => `%${v}` },
+  contains: { op: "like", value: (v) => `%${v}%` },
+  oneOf: { op: "=", value: (v) => sql`ANY(${v})` },
+  greaterThan: { op: ">" },
+  greaterThanOrEquals: { op: ">=" },
+  lessThan: { op: "<" },
+  lessThanOrEquals: { op: "<=" },
+  before: { op: "<" },
+  onOrBefore: { op: "<=" },
+  after: { op: ">" },
+  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: ">" },
+    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}` },
+  },
+};
+
+/**
+ * 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];
+
+    // Handle nested where conditions e.g. using a join table
+    if (conf && conf[snakeCase(key)]) {
+      const rel = conf[snakeCase(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, sql`is not distinct from`, sql`${v}`);
+      continue;
+    }
+
+    for (const op of Object.keys(v)) {
+      const mapping = opMapping[op];
+      if (!mapping) {
+        throw new Error(`invalid where condition: ${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]}`
+        );
+      }
+    }
+  }
+
+  return qb;
+}
+
+module.exports = {
+  applyWhereConditions,
+};

package/src/auditing.js

@@ -0,0 +1,110 @@
+const { AsyncLocalStorage } = require("async_hooks");
+const TraceParent = require("traceparent");
+const { sql, SelectionNode } = require("kysely");
+
+const auditContextStorage = new AsyncLocalStorage();
+
+// withAuditContext creates the audit context from the runtime request body
+// and sets it to in AsyncLocalStorage so that this data is available to the
+// ModelAPI during the execution of actions, jobs and subscribers.
+async function withAuditContext(request, cb) {
+  let audit = {};
+
+  if (request.meta?.identity) {
+    audit.identityId = request.meta.identity.id;
+  }
+  if (request.meta?.tracing?.traceparent) {
+    audit.traceId = TraceParent.fromString(
+      request.meta.tracing.traceparent
+    )?.traceId;
+  }
+
+  return await auditContextStorage.run(audit, () => {
+    return cb();
+  });
+}
+
+// getAuditContext retrieves the audit context from AsyncLocalStorage.
+function getAuditContext() {
+  let auditStore = auditContextStorage.getStore();
+  return {
+    identityId: auditStore?.identityId,
+    traceId: auditStore?.traceId,
+  };
+}
+
+// AuditContextPlugin is a Kysely plugin which ensures that the audit context data
+// is written to Postgres configuration parameters in the same execution as a query.
+// It does this by calling the set_identity_id() and set_trace_id() functions as a
+// clause in the returning statement. It then subsequently drops these from the actual result.
+// This ensures that these parameters are set when the tables' AFTER trigger function executes.
+class AuditContextPlugin {
+  constructor() {
+    this.identityIdAlias = "__keel_identity_id";
+    this.traceIdAlias = "__keel_trace_id";
+  }
+
+  // Appends set_identity_id() and set_trace_id() function calls to the returning statement
+  // of INSERT, UPDATE and DELETE operations.
+  transformQuery(args) {
+    switch (args.node.kind) {
+      case "InsertQueryNode":
+      case "UpdateQueryNode":
+      case "DeleteQueryNode":
+        // Represents a RETURNING clause in a SQL statement.
+        const returning = {
+          kind: "ReturningNode",
+          selections: [],
+        };
+
+        // If the query already has a selection, then append it.
+        if (args.node.returning) {
+          returning.selections.push(...args.node.returning.selections);
+        }
+
+        // Retrieve the audit context from async storage.
+        const audit = getAuditContext();
+
+        if (audit.identityId) {
+          const rawNode = sql`set_identity_id(${audit.identityId})`
+            .as(this.identityIdAlias)
+            .toOperationNode();
+
+          returning.selections.push(SelectionNode.create(rawNode));
+        }
+
+        if (audit.traceId) {
+          const rawNode = sql`set_trace_id(${audit.traceId})`
+            .as(this.traceIdAlias)
+            .toOperationNode();
+
+          returning.selections.push(SelectionNode.create(rawNode));
+        }
+
+        return {
+          ...args.node,
+          returning: returning,
+        };
+    }
+
+    return {
+      ...args.node,
+    };
+  }
+
+  // Drops the set_identity_id() and set_trace_id() fields from the result.
+  transformResult(args) {
+    if (args.result?.rows) {
+      for (let i = 0; i < args.result.rows.length; i++) {
+        delete args.result.rows[i][this.identityIdAlias];
+        delete args.result.rows[i][this.traceIdAlias];
+      }
+    }
+
+    return args.result;
+  }
+}
+
+module.exports.withAuditContext = withAuditContext;
+module.exports.getAuditContext = getAuditContext;
+module.exports.AuditContextPlugin = AuditContextPlugin;

package/src/auditing.test.js

@@ -0,0 +1,330 @@
+import { test, expect, beforeEach } from "vitest";
+const { ModelAPI } = require("./ModelAPI");
+const { PROTO_ACTION_TYPES } = require("./consts");
+const { sql } = require("kysely");
+const { useDatabase, withDatabase } = require("./database");
+const KSUID = require("ksuid");
+const TraceParent = require("traceparent");
+const { withAuditContext } = require("./auditing");
+
+let personAPI;
+const db = useDatabase();
+
+beforeEach(async () => {
+  await sql`
+ 
+  DROP TABLE IF EXISTS post;
+  DROP TABLE IF EXISTS person;
+  DROP TABLE IF EXISTS author;
+
+  CREATE TABLE person(
+      id               text PRIMARY KEY,
+      name             text UNIQUE
+  );
+
+  CREATE OR REPLACE FUNCTION set_identity_id(id VARCHAR)
+  RETURNS TEXT AS $$
+  BEGIN
+      RETURN set_config('audit.identity_id', id, true);
+  END
+  $$ LANGUAGE plpgsql;
+
+  CREATE OR REPLACE FUNCTION set_trace_id(id VARCHAR)
+  RETURNS TEXT AS $$
+  BEGIN
+      RETURN set_config('audit.trace_id', id, true);
+  END
+  $$ LANGUAGE plpgsql;
+  `.execute(db);
+
+  personAPI = new ModelAPI("person", undefined, {});
+});
+
+async function identityIdFromConfigParam(database, nonLocal = true) {
+  const result =
+    await sql`SELECT NULLIF(current_setting('audit.identity_id', ${sql.literal(
+      nonLocal
+    )}), '') AS id`.execute(database);
+  return result.rows[0].id;
+}
+
+async function traceIdFromConfigParam(database, nonLocal = true) {
+  const result =
+    await sql`SELECT NULLIF(current_setting('audit.trace_id', ${sql.literal(
+      nonLocal
+    )}), '') AS id`.execute(database);
+  return result.rows[0].id;
+}
+
+test("auditing - capturing identity id in transaction", async () => {
+  const request = {
+    meta: {
+      identity: { id: KSUID.randomSync().string },
+    },
+  };
+
+  const identityId = request.meta.identity.id;
+
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "James",
+      });
+    });
+
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await identityIdFromConfigParam(db)).toBeNull();
+
+    return row;
+  });
+
+  expect(row.name).toEqual("James");
+  expect(await identityIdFromConfigParam(db)).toBeNull();
+  expect(await identityIdFromConfigParam(db, false)).toBeNull();
+});
+
+test("auditing - capturing tracing in transaction", async () => {
+  const request = {
+    meta: {
+      tracing: {
+        traceparent: "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      },
+    },
+  };
+
+  const traceId = TraceParent.fromString(
+    request.meta.tracing.traceparent
+  ).traceId;
+
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jim",
+      });
+    });
+
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+    expect(await traceIdFromConfigParam(db)).toBeNull();
+
+    return row;
+  });
+
+  expect(row.name).toEqual("Jim");
+  expect(await traceIdFromConfigParam(db)).toBeNull();
+  expect(await traceIdFromConfigParam(db, false)).toBeNull();
+});
+
+test("auditing - capturing identity id without transaction", async () => {
+  const request = {
+    meta: {
+      identity: { id: KSUID.randomSync().string },
+    },
+  };
+
+  const row = await withDatabase(db, false, async ({ sDb }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "James",
+      });
+    });
+
+    expect(await identityIdFromConfigParam(sDb)).toBeNull();
+    expect(await identityIdFromConfigParam(db)).toBeNull();
+
+    return row;
+  });
+
+  expect(row.name).toEqual("James");
+  expect(await identityIdFromConfigParam(db)).toBeNull();
+  expect(await identityIdFromConfigParam(db, false)).toBeNull();
+});
+
+test("auditing - capturing tracing without transaction", async () => {
+  const request = {
+    meta: {
+      tracing: {
+        traceparent: "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      },
+    },
+  };
+
+  const row = await withDatabase(db, false, async ({ sDb }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jim",
+      });
+    });
+
+    expect(await traceIdFromConfigParam(sDb)).toBeNull();
+    expect(await traceIdFromConfigParam(db)).toBeNull();
+
+    return row;
+  });
+
+  expect(row.name).toEqual("Jim");
+  expect(await traceIdFromConfigParam(db)).toBeNull();
+  expect(await traceIdFromConfigParam(db, false)).toBeNull();
+});
+
+test("auditing - no audit context", async () => {
+  const row = await withDatabase(
+    db,
+    PROTO_ACTION_TYPES.CREATE,
+    async ({ transaction }) => {
+      const row = withAuditContext({}, async () => {
+        return await personAPI.create({
+          id: KSUID.randomSync().string,
+          name: "Jake",
+        });
+      });
+
+      expect(await identityIdFromConfigParam(transaction)).toBeNull();
+      expect(await identityIdFromConfigParam(db)).toBeNull();
+      expect(await traceIdFromConfigParam(transaction)).toBeNull();
+      expect(await traceIdFromConfigParam(db)).toBeNull();
+      return row;
+    }
+  );
+
+  expect(KSUID.parse(row.id).string).toEqual(row.id);
+  expect(row.name).toEqual("Jake");
+});
+
+test("auditing - ModelAPI.create", async () => {
+  const request = {
+    meta: {
+      identity: { id: KSUID.randomSync().string },
+      tracing: {
+        traceparent: "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      },
+    },
+  };
+
+  const identityId = request.meta.identity.id;
+  const traceId = TraceParent.fromString(
+    request.meta.tracing.traceparent
+  ).traceId;
+
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jake",
+      });
+    });
+
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+
+    return row;
+  });
+
+  expect(row.name).toEqual("Jake");
+});
+
+test("auditing - ModelAPI.update", async () => {
+  const request = {
+    meta: {
+      identity: { id: KSUID.randomSync().string },
+      tracing: {
+        traceparent: "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      },
+    },
+  };
+
+  const identityId = request.meta.identity.id;
+  const traceId = TraceParent.fromString(
+    request.meta.tracing.traceparent
+  ).traceId;
+
+  const created = await personAPI.create({
+    id: KSUID.randomSync().string,
+    name: "Jake",
+  });
+
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.update({ id: created.id }, { name: "Jim" });
+    });
+
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+
+    return row;
+  });
+
+  expect(row.name).toEqual("Jim");
+});
+
+test("auditing - ModelAPI.delete", async () => {
+  const request = {
+    meta: {
+      identity: { id: KSUID.randomSync().string },
+      tracing: {
+        traceparent: "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      },
+    },
+  };
+
+  const identityId = request.meta.identity.id;
+  const traceId = TraceParent.fromString(
+    request.meta.tracing.traceparent
+  ).traceId;
+
+  const created = await personAPI.create({
+    id: KSUID.randomSync().string,
+    name: "Jake",
+  });
+
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.delete({ id: created.id });
+    });
+
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+
+    return row;
+  });
+
+  expect(row).toEqual(created.id);
+});
+
+test("auditing - identity id and trace id fields dropped from result", async () => {
+  const request = {
+    meta: {
+      identity: { id: KSUID.randomSync().string },
+      tracing: {
+        traceparent: "00-80e1afed08e019fc1110464cfa66635c-7a085853722dc6d2-01",
+      },
+    },
+  };
+
+  const identityId = request.meta.identity.id;
+  const traceId = TraceParent.fromString(
+    request.meta.tracing.traceparent
+  ).traceId;
+
+  const row = await withDatabase(db, true, async ({ transaction }) => {
+    const row = withAuditContext(request, async () => {
+      return await personAPI.create({
+        id: KSUID.randomSync().string,
+        name: "Jake",
+      });
+    });
+
+    expect(await identityIdFromConfigParam(transaction)).toEqual(identityId);
+    expect(await traceIdFromConfigParam(transaction)).toEqual(traceId);
+
+    return row;
+  });
+
+  expect(row.name).toEqual("Jake");
+  expect(row.keelIdentityId).toBeUndefined();
+  expect(row.keelTraceId).toBeUndefined();
+  expect(Object.keys(row).length).toEqual(2);
+});

package/src/camelCasePlugin.js

@@ -0,0 +1,52 @@
+const { CamelCasePlugin } = require("kysely");
+const { isPlainObject, isRichType } = require("./type-utils");
+
+// KeelCamelCasePlugin is a wrapper around kysely's CamelCasePlugin. The behaviour is the same apart from the fact that
+// nested objects that are of a rich keel data type, such as Duration, are skipped so that they continue to be
+// implementations of the rich data classes defined by Keel.
+class KeelCamelCasePlugin {
+  constructor(opt) {
+    this.opt = opt;
+    this.CamelCasePlugin = new CamelCasePlugin(opt);
+  }
+
+  transformQuery(args) {
+    return this.CamelCasePlugin.transformQuery(args);
+  }
+
+  async transformResult(args) {
+    if (args.result.rows && Array.isArray(args.result.rows)) {
+      return {
+        ...args.result,
+        rows: args.result.rows.map((row) => this.mapRow(row)),
+      };
+    }
+    return args.result;
+  }
+  mapRow(row) {
+    return Object.keys(row).reduce((obj, key) => {
+      // Fields using @sequence will have a corresponding __sequence field which we drop as we don't want to return it
+      if (key.endsWith("__sequence")) {
+        return obj;
+      }
+      let value = row[key];
+      if (Array.isArray(value)) {
+        value = value.map((it) =>
+          canMap(it, this.opt) ? this.mapRow(it) : it
+        );
+      } else if (canMap(value, this.opt)) {
+        value = this.mapRow(value);
+      }
+      obj[this.CamelCasePlugin.camelCase(key)] = value;
+      return obj;
+    }, {});
+  }
+}
+
+function canMap(obj, opt) {
+  return (
+    isPlainObject(obj) && !opt?.maintainNestedObjectKeys && !isRichType(obj)
+  );
+}
+
+module.exports.KeelCamelCasePlugin = KeelCamelCasePlugin;

package/src/casing.js

@@ -0,0 +1,54 @@
+const { snakeCase, camelCase } = require("change-case");
+
+function camelCaseObject(obj = {}) {
+  const r = {};
+  for (const key of Object.keys(obj)) {
+    r[
+      camelCase(key, {
+        transform: camelCaseTransform,
+        splitRegexp: [
+          /([a-z0-9])([A-Z])/g,
+          /([A-Z])([A-Z][a-z])/g,
+          /([a-zA-Z])([0-9])/g,
+        ],
+      })
+    ] = obj[key];
+  }
+  return r;
+}
+
+function snakeCaseObject(obj) {
+  const r = {};
+  for (const key of Object.keys(obj)) {
+    r[
+      snakeCase(key, {
+        splitRegexp: [
+          /([a-z0-9])([A-Z])/g,
+          /([A-Z])([A-Z][a-z])/g,
+          /([a-zA-Z])([0-9])/g,
+        ],
+      })
+    ] = obj[key];
+  }
+  return r;
+}
+
+function upperCamelCase(s) {
+  s = camelCase(s);
+  return s[0].toUpperCase() + s.substring(1);
+}
+
+function camelCaseTransform(input, index) {
+  if (index === 0) return input.toLowerCase();
+  const firstChar = input.charAt(0);
+  const lowerChars = input.substr(1).toLowerCase();
+  return `${firstChar.toUpperCase()}${lowerChars}`;
+}
+
+module.exports = {
+  camelCaseObject,
+  snakeCaseObject,
+  snakeCase,
+  camelCase,
+  upperCamelCase,
+};