@teamkeel/functions-runtime 0.366.0-auditident7 → 0.366.0

package/package.json

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

package/src/ModelAPI.js

@@ -1,10 +1,8 @@
 const { useDatabase } = require("./database");
-const { getAuditContext } = require("./auditing");
 const { QueryBuilder } = require("./QueryBuilder");
 const { QueryContext } = require("./QueryContext");
 const { applyWhereConditions } = require("./applyWhereConditions");
 const { applyJoins } = require("./applyJoins");
-const { sql } = require("kysely");
 
 const {
   applyLimit,
@@ -50,52 +48,12 @@ class ModelAPI {
     this._modelName = upperCamelCase(this._tableName);
   }
 
-  // execute sets the audit context in the database and then runs individual
-  // database statements within a transaction if one hasn't been opened, which
-  // is necessary because the audit parameters will only be available within transactions.
-  async #execute(fn) {
-    const db = useDatabase();
-
-    try {
-      if (db.isTransaction) {
-        await this.#setAuditParameters(db);
-        return await fn(db);
-      } else {
-        return await db.transaction().execute(async (transaction) => {
-          await this.#setAuditParameters(transaction);
-          return fn(transaction);
-        });
-      }
-    } catch (e) {
-      throw new DatabaseError(e);
-    }
-  }
-
-  // setAuditParameters sets audit context data to configuration parameters
-  // in the database so that they can be read by the triggered auditing function.
-  async #setAuditParameters(transaction) {
-    const audit = getAuditContext();
-    const statements = [];
-
-    if (audit.identityId) {
-      statements.push(`CALL set_identity_id('${audit.identityId}');`);
-    }
-
-    if (audit.traceId) {
-      statements.push(`CALL set_trace_id('${audit.traceId}');`);
-    }
-
-    if (statements.length > 0) {
-      const stmt = statements.join("");
-      await sql.raw(stmt).execute(transaction);
-    }
-  }
-
   async create(values) {
     const name = tracing.spanNameForModelAPI(this._modelName, "create");
+    const db = useDatabase();
 
     return tracing.withSpan(name, async (span) => {
-      return await this.#execute(async (db) => {
+      try {
         const query = db
           .insertInto(this._tableName)
           .values(
@@ -107,8 +65,11 @@ class ModelAPI {
 
         span.setAttribute("sql", query.compile().sql);
         const row = await query.executeTakeFirstOrThrow();
+
         return camelCaseObject(row);
-      });
+      } catch (e) {
+        throw new DatabaseError(e);
+      }
     });
   }
 
@@ -195,49 +156,48 @@ class ModelAPI {
 
   async update(where, values) {
     const name = tracing.spanNameForModelAPI(this._modelName, "update");
+    const db = useDatabase();
 
     return tracing.withSpan(name, async (span) => {
-      return await this.#execute(async (db) => {
-        let builder = db.updateTable(this._tableName).returningAll();
+      let builder = db.updateTable(this._tableName).returningAll();
 
-        builder = builder.set(snakeCaseObject(values));
+      builder = builder.set(snakeCaseObject(values));
 
-        const context = new QueryContext(
-          [this._tableName],
-          this._tableConfigMap
-        );
+      const context = new QueryContext([this._tableName], this._tableConfigMap);
 
-        // TODO: support joins for update
-        builder = applyWhereConditions(context, builder, where);
+      // TODO: support joins for update
+      builder = applyWhereConditions(context, builder, where);
 
-        span.setAttribute("sql", builder.compile().sql);
+      span.setAttribute("sql", builder.compile().sql);
 
+      try {
         const row = await builder.executeTakeFirstOrThrow();
         return camelCaseObject(row);
-      });
+      } catch (e) {
+        throw new DatabaseError(e);
+      }
     });
   }
 
   async delete(where) {
     const name = tracing.spanNameForModelAPI(this._modelName, "delete");
+    const db = useDatabase();
 
     return tracing.withSpan(name, async (span) => {
-      return await this.#execute(async (db) => {
-        let builder = db.deleteFrom(this._tableName).returning(["id"]);
+      let builder = db.deleteFrom(this._tableName).returning(["id"]);
 
-        const context = new QueryContext(
-          [this._tableName],
-          this._tableConfigMap
-        );
-
-        // TODO: support joins for delete
-        builder = applyWhereConditions(context, builder, where);
+      const context = new QueryContext([this._tableName], this._tableConfigMap);
 
-        span.setAttribute("sql", builder.compile().sql);
+      // TODO: support joins for delete
+      builder = applyWhereConditions(context, builder, where);
 
+      span.setAttribute("sql", builder.compile().sql);
+      try {
         const row = await builder.executeTakeFirstOrThrow();
         return row.id;
-      });
+      } catch (e) {
+        throw new DatabaseError(e);
+      }
     });
   }
 

package/src/auditing.js

@@ -44,14 +44,6 @@ class AuditContextPlugin {
     this.traceIdAlias = "__keel_trace_id";
   }
 
-  #setIdentityClause(value) {
-    return `set_identity_id('${value}')`;
-  }
-
-  #setTraceIdClause(value) {
-    return `set_trace_id('${value}')`;
-  }
-
   // Appends set_identity_id() and set_trace_id() function calls to the returning statement
   // of INSERT, UPDATE and DELETE operations.
   transformQuery(args) {
@@ -59,10 +51,13 @@ class AuditContextPlugin {
       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);
         }
@@ -71,10 +66,7 @@ class AuditContextPlugin {
         const audit = getAuditContext();
 
         if (audit.identityId) {
-          const rawNode = sql
-            .raw(
-              this.#setIdentityClause(audit.identityId, this.identityIdAlias)
-            )
+          const rawNode = sql`set_identity_id(${audit.identityId})`
             .as(this.identityIdAlias)
             .toOperationNode();
 
@@ -82,8 +74,7 @@ class AuditContextPlugin {
         }
 
         if (audit.traceId) {
-          const rawNode = sql
-            .raw(this.#setTraceIdClause(audit.traceId))
+          const rawNode = sql`set_trace_id(${audit.traceId})`
             .as(this.traceIdAlias)
             .toOperationNode();
 

package/src/database.js

@@ -129,7 +129,7 @@ class InstrumentedClient extends pg.Client {
       sqlAttribute = true;
     }
 
-    return await withSpan(spanName, function (span) {
+    return withSpan(spanName, function (span) {
       if (sqlAttribute) {
         span.setAttribute("sql", args[0]);
       }

package/src/handleRequest.test.js

@@ -282,10 +282,8 @@ describe("ModelAPI error handling", () => {
       },
     });
   });
-
   test("when there is a uniqueness constraint error", async () => {
     await sql`
-
     INSERT INTO post (id, title, author_id) values(${
       KSUID.randomSync().string
     }, 'hello', 'adam')
@@ -358,113 +356,3 @@ describe("ModelAPI error handling", () => {
     });
   });
 });
-
-// The following tests assert on the various
-// jsonrpc responses that *should* happen when a user
-// writes a custom function that inadvertently causes a pg constraint error to occur inside of our ModelAPI class instance.
-describe("ModelAPI error handling", () => {
-  let functionConfig;
-  let db;
-
-  beforeEach(async () => {
-    process.env.KEEL_DB_CONN_TYPE = "pg";
-    process.env.KEEL_DB_CONN = `postgresql://postgres:postgres@localhost:5432/functions-runtime`;
-
-    db = useDatabase();
-
-    await sql`
-    DROP TABLE IF EXISTS post;
-    DROP TABLE IF EXISTS author;
-
-    CREATE TABLE author(
-      "id"               text PRIMARY KEY,
-      "name"             text NOT NULL
-    );
-  
-    CREATE TABLE post(
-      "id"            text PRIMARY KEY,
-      "title"         text NOT NULL UNIQUE,
-      "author_id"     text NOT NULL REFERENCES author(id)
-    );
-    `.execute(db);
-
-    await sql`
-      INSERT INTO author (id, name) VALUES ('adam', 'adam bull')
-    `.execute(db);
-
-    const models = {
-      post: new ModelAPI("post", undefined, {
-        post: {
-          author: {
-            relationshipType: "belongsTo",
-            foreignKey: "author_id",
-            referencesTable: "person",
-          },
-        },
-      }),
-    };
-
-    functionConfig = {
-      permissionFns: {},
-      actionTypes: {
-        createPost: PROTO_ACTION_TYPES.CREATE,
-        deletePost: PROTO_ACTION_TYPES.DELETE,
-      },
-      functions: {
-        createPost: async (ctx, inputs) => {
-          new Permissions().allow();
-
-          const post = await models.post.create({
-            id: KSUID.randomSync().string,
-            ...inputs,
-          });
-
-          return post;
-        },
-        deletePost: async (ctx, inputs) => {
-          new Permissions().allow();
-
-          const deleted = await models.post.delete(inputs);
-
-          return deleted;
-        },
-      },
-      createContextAPI: () => ({}),
-    };
-  });
-
-  test("when kysely returns a no result error", async () => {
-    // a kysely NoResultError is thrown when attempting to delete/update a non existent record.
-    const rpcReq = createJSONRPCRequest("123", "deletePost", {
-      id: "non-existent-id",
-    });
-
-    expect(await handleRequest(rpcReq, functionConfig)).toEqual({
-      id: "123",
-      jsonrpc: "2.0",
-      error: {
-        code: RuntimeErrors.RecordNotFoundError,
-        message: "no result",
-      },
-    });
-  });
-
-  test("when there is a not null constraint error", async () => {
-    const rpcReq = createJSONRPCRequest("123", "createPost", { title: null });
-
-    expect(await handleRequest(rpcReq, functionConfig)).toEqual({
-      id: "123",
-      jsonrpc: "2.0",
-      error: {
-        code: RuntimeErrors.NotNullConstraintError,
-        message: 'null value in column "title" violates not-null constraint',
-        data: {
-          code: "23502",
-          column: "title",
-          detail: expect.stringContaining("Failing row contains"),
-          table: "post",
-        },
-      },
-    });
-  });
-});