@teamkeel/testing-runtime 0.365.15-prerelease2 → 0.365.15-prerelease21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teamkeel/testing-runtime",
-  "version": "0.365.15-prerelease2",
+  "version": "0.365.15-prerelease21",
   "description": "Internal package used by the generated @teamkeel/testing package",
   "exports": "./src/index.mjs",
   "typings": "src/index.d.ts",

package/src/ActionExecutor.mjs

@@ -1,85 +1,10 @@
-import jwt from "jsonwebtoken";
+import { Executor } from "./Executor.mjs";
 
-export class ActionExecutor {
+export class ActionExecutor extends Executor {
   constructor(props) {
-    this._identity = props.identity || null;
-    this._authToken = props.authToken || null;
+    props.apiBaseUrl = process.env.KEEL_TESTING_ACTIONS_API_URL;
+    props.parseJsonResult = true;
 
-    // Return a proxy which will return a bound version of the
-    // _execute method for any unknown properties. This creates
-    // the actions API we want but in a dynamic way without needing
-    // codegen. We then generate the right type definitions for
-    // this class in the @teamkeel/testing package.
-    return new Proxy(this, {
-      get(target, prop) {
-        const v = Reflect.get(...arguments);
-        if (v !== undefined) {
-          return v;
-        }
-        return target._execute.bind(target, prop);
-      },
-    });
-  }
-  withIdentity(i) {
-    return new ActionExecutor({ identity: i });
-  }
-  withAuthToken(t) {
-    return new ActionExecutor({ authToken: t });
-  }
-  _execute(method, params) {
-    const headers = { "Content-Type": "application/json" };
-
-    // An Identity instance is provided make a JWT
-    if (this._identity !== null) {
-      headers["Authorization"] =
-        "Bearer " +
-        jwt.sign(
-          {},
-          // Not using a signing algorithm, therefore the private key is undefined
-          undefined,
-          {
-            algorithm: "none",
-            expiresIn: 60 * 60 * 24,
-            subject: this._identity.id,
-            issuer: "keel",
-          }
-        );
-    }
-
-    // If an auth token is provided that can be sent as-is
-    if (this._authToken !== null) {
-      headers["Authorization"] = "Bearer " + this._authToken;
-    }
-
-    // Use the HTTP JSON API as that returns more friendly errors than
-    // the JSON-RPC API.
-    return fetch(process.env.KEEL_TESTING_ACTIONS_API_URL + "/" + method, {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers,
-    }).then((r) => {
-      if (r.status !== 200) {
-        // For non-200 first read the response as text
-        return r.text().then((t) => {
-          let d;
-          try {
-            d = JSON.parse(t);
-          } catch (e) {
-            // If JSON parsing fails then throw an error with the
-            // response text as the message
-            throw new Error(t);
-          }
-          // Otherwise throw the parsed JSON error response
-          // We override toString as otherwise you get expect errors like:
-          //   `expected to resolve but rejected with "[object Object]"`
-          Object.defineProperty(d, "toString", {
-            value: () => t,
-            enumerable: false,
-          });
-          throw d;
-        });
-      }
-      return r.json();
-    });
+    super(props);
   }
 }

package/src/Executor.mjs

@@ -0,0 +1,111 @@
+import jwt from "jsonwebtoken";
+
+export class Executor {
+  constructor(props) {
+    this._identity = props.identity || null;
+    this._authToken = props.authToken || null;
+    this._apiBaseUrl = props.apiBaseUrl;
+    this._parseJsonResult = props.parseJsonResult;
+
+    // Return a proxy which will return a bound version of the
+    // _execute method for any unknown properties. This creates
+    // the actions API we want but in a dynamic way without needing
+    // codegen. We then generate the right type definitions for
+    // this class in the @teamkeel/testing package.
+    return new Proxy(this, {
+      get(target, prop) {
+        const v = Reflect.get(...arguments);
+        if (v !== undefined) {
+          return v;
+        }
+        return target._execute.bind(target, prop);
+      },
+    });
+  }
+  withIdentity(i) {
+    return new Executor({
+      identity: i,
+      apiBaseUrl: this._apiBaseUrl,
+      parseJsonResult: this._parseJsonResult,
+    });
+  }
+  withAuthToken(t) {
+    return new Executor({
+      authToken: t,
+      apiBaseUrl: this._apiBaseUrl,
+      parseJsonResult: this._parseJsonResult,
+    });
+  }
+  _execute(method, params) {
+    const headers = { "Content-Type": "application/json" };
+
+    // An Identity instance is provided make a JWT
+    if (this._identity !== null) {
+      const base64pk = process.env.KEEL_DEFAULT_PK;
+      let privateKey = undefined;
+
+      if (base64pk) {
+        privateKey = Buffer.from(base64pk, "base64").toString("utf8");
+      }
+
+      headers["Authorization"] =
+        "Bearer " +
+        jwt.sign({}, privateKey, {
+          algorithm: privateKey ? "RS256" : "none",
+          expiresIn: 60 * 60 * 24,
+          subject: this._identity.id,
+          issuer: "keel",
+        });
+    }
+
+    // If an auth token is provided that can be sent as-is
+    if (this._authToken !== null) {
+      headers["Authorization"] = "Bearer " + this._authToken;
+    }
+
+    if (params?.scheduled) {
+      headers["X-Trigger-Type"] = "scheduled";
+    } else {
+      headers["X-Trigger-Type"] = "manual";
+    }
+
+    // Use the HTTP JSON API as that returns more friendly errors than
+    // the JSON-RPC API.
+    return fetch(this._apiBaseUrl + "/" + method, {
+      method: "POST",
+      body: JSON.stringify(params),
+      headers,
+    }).then((r) => {
+      if (r.status !== 200) {
+        // For non-200 first read the response as text
+        return r.text().then((t) => {
+          let d;
+          try {
+            d = JSON.parse(t);
+          } catch (e) {
+            if ("DEBUG" in process.env) {
+              console.log(e);
+            }
+            // If JSON parsing fails then throw an error with the
+            // response text as the message
+            throw new Error(t);
+          }
+          // Otherwise throw the parsed JSON error response
+          // We override toString as otherwise you get expect errors like:
+          //   `expected to resolve but rejected with "[object Object]"`
+          Object.defineProperty(d, "toString", {
+            value: () => t,
+            enumerable: false,
+          });
+          throw d;
+        });
+      }
+
+      if (this._parseJsonResult) {
+        return r.json();
+      } else {
+        return true;
+      }
+    });
+  }
+}

package/src/JobExecutor.mjs

@@ -1,94 +1,10 @@
-import jwt from "jsonwebtoken";
+import { Executor } from "./Executor.mjs";
 
-export class JobExecutor {
+export class JobExecutor extends Executor {
   constructor(props) {
-    this._identity = props.identity || null;
-    this._authToken = props.authToken || null;
+    props.apiBaseUrl = process.env.KEEL_TESTING_JOBS_URL;
+    props.parseJsonResult = false;
 
-    // Return a proxy which will return a bound version of the
-    // _execute method for any unknown properties. This creates
-    // the jobs API we want but in a dynamic way without needing
-    // codegen. We then generate the right type definitions for
-    // this class in the @teamkeel/testing package.
-    return new Proxy(this, {
-      get(target, prop) {
-        const v = Reflect.get(...arguments);
-        if (v !== undefined) {
-          return v;
-        }
-        return target._execute.bind(target, prop);
-      },
-    });
-  }
-  withIdentity(i) {
-    return new JobExecutor({ identity: i });
-  }
-  withAuthToken(t) {
-    return new JobExecutor({ authToken: t });
-  }
-  _execute(method, params) {
-    const headers = { "Content-Type": "application/json" };
-
-    // An Identity instance is provided make a JWT
-    if (this._identity !== null) {
-      headers["Authorization"] =
-        "Bearer " +
-        jwt.sign(
-          {},
-          // Not using a signing algorithm, therefore the private key is undefined
-          undefined,
-          {
-            algorithm: "none",
-            expiresIn: 60 * 60 * 24,
-            subject: this._identity.id,
-            issuer: "keel",
-          }
-        );
-    }
-
-    // If an auth token is provided that can be sent as-is
-    if (this._authToken !== null) {
-      headers["Authorization"] = "Bearer " + this._authToken;
-    }
-
-    if (params?.scheduled) {
-      headers["X-Trigger-Type"] = "scheduled";
-    } else {
-      headers["X-Trigger-Type"] = "manual";
-    }
-
-    return fetch(process.env.KEEL_TESTING_JOBS_URL + "/" + method, {
-      method: "POST",
-      body: JSON.stringify(params),
-      headers,
-    }).then((r) => {
-      if (r.status !== 200) {
-        // For non-200 first read the response as text
-        return r.text().then((t) => {
-          let d;
-          try {
-            d = JSON.parse(t);
-          } catch (e) {
-            if ("DEBUG" in process.env) {
-              console.log(e);
-            }
-            // If JSON parsing fails then throw an error with the
-            // response text as the message
-            throw new Error(t);
-          }
-          // Otherwise throw the parsed JSON error response
-          // We override toString as otherwise you get expect errors like:
-          //   `expected to resolve but rejected with "[object Object]"`
-          Object.defineProperty(d, "toString", {
-            value: () => t,
-            enumerable: false,
-          });
-
-          throw d;
-        });
-      }
-
-      return true;
-    });
+    super(props);
   }
 }

package/src/SubscriberExecutor.mjs

@@ -0,0 +1,10 @@
+import { Executor } from "./Executor.mjs";
+
+export class SubscriberExecutor extends Executor {
+  constructor(props) {
+    props.apiBaseUrl = process.env.KEEL_TESTING_SUBSCRIBERS_URL;
+    props.parseJsonResult = false;
+
+    super(props);
+  }
+}

package/src/index.mjs

@@ -1,5 +1,6 @@
 export { sql } from "kysely";
 export { ActionExecutor } from "./ActionExecutor.mjs";
 export { JobExecutor } from "./JobExecutor.mjs";
+export { SubscriberExecutor } from "./SubscriberExecutor.mjs";
 export { toHaveError } from "./toHaveError.mjs";
 export { toHaveAuthorizationError } from "./toHaveAuthorizationError.mjs";

package/src/toHaveAuthorizationError.mjs

@@ -9,9 +9,12 @@ export async function toHaveAuthorizationError(received) {
     };
   } catch (err) {
     return {
-      pass: err.code === "ERR_PERMISSION_DENIED",
+      pass:
+        err.code === "ERR_PERMISSION_DENIED" || err.code === "ERR_UNAUTHORIZED",
       message: () =>
-        `expected there to be ${isNot ? "no " : ""}ERR_PERMISSION_DENIED error`,
+        `expected there to be ${
+          isNot ? "no " : ""
+        }ERR_PERMISSION_DENIED or ERR_UNAUTHORIZED error`,
       actual: err,
       expected: {
         ...err,