@teamkeel/testing-runtime 0.415.4 → 0.416.0

package/package.json

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

package/src/Executor.mjs

@@ -1,5 +1,5 @@
 import jwt from "jsonwebtoken";
-import { InlineFile, File, Duration } from "@teamkeel/functions-runtime";
+import { parseInputs, parseOutputs, reviver } from "./parsing.mjs";
 
 export class Executor {
   constructor(props) {
@@ -123,118 +123,3 @@ export class Executor {
     });
   }
 }
-
-async function parseInputs(inputs) {
-  if (inputs != null && typeof inputs === "object") {
-    for (const keys of Object.keys(inputs)) {
-      if (inputs[keys] !== null && typeof inputs[keys] === "object") {
-        if (isDuration(inputs[keys])) {
-          inputs[keys] = inputs[keys].toISOString();
-        } else if (isInlineFileOrFile(inputs[keys])) {
-          const contents = await inputs[keys].read();
-          inputs[keys] = `data:${inputs[keys].contentType};name=${
-            inputs[keys].filename
-          };base64,${contents.toString("base64")}`;
-        } else {
-          inputs[keys] = await parseInputs(inputs[keys]);
-        }
-      }
-    }
-  }
-  return inputs;
-}
-
-function isInlineFileOrFile(obj) {
-  return (
-    obj &&
-    typeof obj === "object" &&
-    (obj.constructor.name === "InlineFile" || obj.constructor.name === "File")
-  );
-}
-
-function isDuration(obj) {
-  return obj && typeof obj === "object" && obj.constructor.name === "Duration";
-}
-
-function parseOutputs(data) {
-  if (!data) {
-    return null;
-  }
-
-  if (!isPlainObject(data)) {
-    return data;
-  }
-
-  const keys = data ? Object.keys(data) : [];
-  const row = {};
-
-  for (const key of keys) {
-    const value = data[key];
-
-    if (isPlainObject(value)) {
-      if (value.key && value.size && value.filename && value.contentType) {
-        row[key] = File.fromDbRecord(value);
-      } else {
-        row[key] = parseOutputs(value);
-      }
-    } else if (
-      Array.isArray(value) &&
-      value.every((item) => typeof item === "object" && item !== null)
-    ) {
-      const arr = [];
-      for (let item of value) {
-        if (item.key && item.size && item.filename && item.contentType) {
-          arr.push(File.fromDbRecord(item));
-        } else {
-          arr.push(parseOutputs(item));
-        }
-      }
-      row[key] = arr;
-    } else {
-      row[key] = value;
-    }
-  }
-  return row;
-}
-
-function isPlainObject(obj) {
-  return Object.prototype.toString.call(obj) === "[object Object]";
-}
-
-const dateFormat =
-  /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
-
-function reviver(key, value) {
-  // Handle date strings
-  if (typeof value === "string") {
-    if (dateFormat.test(value)) {
-      return new Date(value);
-    }
-  }
-
-  // Handle nested objects
-  if (value !== null && typeof value === "object") {
-    // Handle arrays
-    if (Array.isArray(value)) {
-      return value.map((item) => {
-        if (typeof item === "string") {
-          if (dateFormat.test(item)) {
-            return new Date(item);
-          }
-        }
-        return item;
-      });
-    }
-
-    // Handle plain objects
-    for (const k in value) {
-      if (typeof value[k] === "string") {
-        if (dateFormat.test(value[k])) {
-          value[k] = new Date(value[k]);
-        }
-      }
-    }
-  }
-
-  return value;
-}

package/src/FlowExecutor.mjs

@@ -0,0 +1,173 @@
+import { parseInputs, parseOutputs, reviver } from "./parsing.mjs";
+
+export class FlowExecutor {
+  constructor(props) {
+    this._flowUrl = process.env.KEEL_TESTING_FLOWS_API_URL + "/" + props.name;
+    this._name = props.name;
+    this._identity = props.identity || null;
+    this._authToken = props.authToken || null;
+  }
+
+  withIdentity(i) {
+    return new FlowExecutor({
+      name: this._name,
+      identity: i,
+      apiBaseUrl: this._apiBaseUrl,
+      parseJsonResult: this._parseJsonResult,
+    });
+  }
+  withAuthToken(t) {
+    return new FlowExecutor({
+      name: this._name,
+      authToken: t,
+      apiBaseUrl: this._apiBaseUrl,
+      parseJsonResult: this._parseJsonResult,
+    });
+  }
+
+  headers() {
+    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: "https://keel.so",
+        });
+    }
+
+    // If an auth token is provided that can be sent as-is
+    if (this._authToken !== null) {
+      headers["Authorization"] = "Bearer " + this._authToken;
+    }
+
+    return headers;
+  }
+
+  async start(inputs) {
+    return parseInputs(inputs).then((parsed) => {
+      // Use the HTTP JSON API as that returns more friendly errors than
+      // the JSON-RPC API.
+      return fetch(this._flowUrl, {
+        method: "POST",
+        body: JSON.stringify(parsed),
+        headers: this.headers(),
+      }).then(handleResponse);
+    });
+  }
+
+  async get(id) {
+    return fetch(this._flowUrl + "/" + id, {
+      method: "GET",
+      headers: this.headers(),
+    }).then(handleResponse);
+  }
+
+  async cancel(id) {
+    return fetch(this._flowUrl + "/" + id + "/cancel", {
+      method: "POST",
+      headers: this.headers(),
+    }).then(handleResponse);
+  }
+
+  async putStepValues(id, stepId, values, action) {
+    let url = this._flowUrl + "/" + id + "/" + stepId;
+
+    if (action) {
+      // If an action is provided then we need to add it to the URL
+      const queryString = new URLSearchParams({ action }).toString();
+      url = `${url}?${queryString}`;
+    }
+
+    return await fetch(url, {
+      method: "PUT",
+      body: JSON.stringify(values),
+      headers: this.headers(),
+    }).then(handleResponse);
+  }
+
+  async untilFinished(id, timeout = 5000) {
+    const startTime = Date.now();
+
+    while (true) {
+      if (Date.now() - startTime > timeout) {
+        throw new Error(
+          `timed out waiting for flow run to reach a completed state after ${timeout}ms`
+        );
+      }
+
+      const flow = await this.get(id);
+
+      if (flow.status === "COMPLETED" || flow.status === "FAILED") {
+        return flow;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+
+  async untilAwaitingInput(id, timeout = 5000) {
+    const startTime = Date.now();
+
+    while (true) {
+      if (Date.now() - startTime > timeout) {
+        throw new Error(
+          `timed out waiting for flow run to reach a completed state after ${timeout}ms`
+        );
+      }
+
+      const flow = await this.get(id);
+
+      if (flow.status === "AWAITING_INPUT") {
+        return flow;
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+}
+
+function handleResponse(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 r.text().then((t) => {
+    const response = JSON.parse(t, reviver);
+    response.input = parseOutputs(response.input);
+
+    return response;
+  });
+}

package/src/index.d.ts

@@ -17,3 +17,195 @@ declare module "vitest" {
   interface Assertion<T = any> extends CustomMatchers<T> {}
   interface AsymmetricMatchersContaining extends CustomMatchers {}
 }
+
+// Flow Status Types
+export type FlowStatus =
+  | "NEW"
+  | "RUNNING"
+  | "AWAITING_INPUT"
+  | "FAILED"
+  | "COMPLETED"
+  | "CANCELLED";
+
+// Step Types
+export type StepType = "FUNCTION" | "UI" | "COMPLETE";
+
+// Step Status Types
+export type StepStatus =
+  | "NEW"
+  | "PENDING"
+  | "FAILED"
+  | "COMPLETED"
+  | "CANCELLED";
+
+// Stage Configuration
+export interface FlowStage {
+  key: string;
+  name: string;
+  description: string;
+}
+
+// Flow Configuration
+export interface FlowConfig {
+  title: string;
+  description?: string;
+  stages?: FlowStage[];
+}
+
+// UI Action Configuration
+export interface UIAction {
+  label: string;
+  mode: "primary" | "secondary";
+  value: string;
+}
+
+// UI Input Elements
+export interface UITextInput {
+  __type: "ui.input.text";
+  label: string;
+  name: string;
+  disabled?: boolean;
+  optional?: boolean;
+  defaultValue?: string;
+  placeholder?: string;
+  validationError?: string;
+}
+
+export interface UINumberInput {
+  __type: "ui.input.number";
+  label: string;
+  name: string;
+  disabled?: boolean;
+  optional?: boolean;
+  defaultValue?: number;
+  validationError?: string;
+}
+
+export interface UIBooleanInput {
+  __type: "ui.input.boolean";
+  label: string;
+  name: string;
+  disabled?: boolean;
+  optional?: boolean;
+  mode: "checkbox";
+  validationError?: string;
+}
+
+// UI Display Elements
+export interface UIDivider {
+  __type: "ui.display.divider";
+}
+
+export interface UIMarkdown {
+  __type: "ui.display.markdown";
+  content: string;
+}
+
+export interface UIGrid {
+  __type: "ui.display.grid";
+  data: Array<{ title: string; [key: string]: any }>;
+}
+
+// UI Complete Element
+export interface UIComplete {
+  __type: "ui.complete";
+  title: string;
+  description?: string;
+  stage?: string;
+  content: UIElement[];
+}
+
+// UI Page Element
+export interface UIPage {
+  __type: "ui.page";
+  title: string;
+  description?: string;
+  content: UIElement[];
+  actions?: UIAction[];
+  hasValidationErrors: boolean;
+  validationError?: string;
+}
+
+// Union type for all UI elements
+export type UIElement =
+  | UITextInput
+  | UINumberInput
+  | UIBooleanInput
+  | UIDivider
+  | UIMarkdown
+  | UIGrid;
+
+// Union type for UI configurations
+export type UIConfig = UIPage | UIComplete;
+
+declare class FlowExecutor<Input = {}> {
+  withIdentity(identity: sdk.Identity): FlowExecutor<Input>;
+  withAuthToken(token: string): FlowExecutor<Input>;
+  start(inputs: Input): Promise<FlowRun<Input>>;
+  get(id: string): Promise<FlowRun<Input>>;
+  cancel(id: string): Promise<FlowRun<Input>>;
+  putStepValues(
+    id: string,
+    stepId: string,
+    values: Record<string, any>,
+    action?: string
+  ): Promise<FlowRun<Input>>;
+  untilAwaitingInput(id: string): Promise<FlowRun<Input>>;
+  untilFinished(id: string): Promise<FlowRun<Input>>;
+}
+
+// Step Definition
+export interface FlowStep {
+  id: string;
+  name: string;
+  runId: string;
+  stage: string | null;
+  status: StepStatus;
+  type: StepType;
+  value: any;
+  error: string | null;
+  startTime: string | null;
+  endTime: string | null;
+  createdAt: string;
+  updatedAt: string;
+  ui: UIConfig | null;
+}
+
+// Flow Run Definition
+export interface FlowRun<Input = {}> {
+  id: string;
+  traceId: string;
+  status: FlowStatus;
+  name: string;
+  startedBy: Date;
+  input: Input | {};
+  data: any;
+  steps: FlowStep[];
+  createdAt: Date;
+  updatedAt: Date;
+  config: FlowConfig;
+}
+
+// Step Values Request
+export interface PutStepValuesRequest {
+  name: string;
+  runId: string;
+  stepId: string;
+  values: Record<string, any>;
+  token: string;
+  action?: string | null;
+}
+
+// Flow Start Request
+export interface StartFlowRequest {
+  name: string;
+  token: string;
+  body: Record<string, any>;
+}
+
+// Flow Get Request
+export interface GetFlowRequest {
+  name: string;
+  id: string;
+  token: string;
+}

package/src/index.mjs

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

package/src/parsing.mjs

@@ -0,0 +1,116 @@
+import { File } from "@teamkeel/functions-runtime";
+
+export async function parseInputs(inputs) {
+  if (inputs != null && typeof inputs === "object") {
+    for (const keys of Object.keys(inputs)) {
+      if (inputs[keys] !== null && typeof inputs[keys] === "object") {
+        if (isDuration(inputs[keys])) {
+          inputs[keys] = inputs[keys].toISOString();
+        } else if (isInlineFileOrFile(inputs[keys])) {
+          const contents = await inputs[keys].read();
+          inputs[keys] = `data:${inputs[keys].contentType};name=${
+            inputs[keys].filename
+          };base64,${contents.toString("base64")}`;
+        } else {
+          inputs[keys] = await parseInputs(inputs[keys]);
+        }
+      }
+    }
+  }
+  return inputs;
+}
+
+function isInlineFileOrFile(obj) {
+  return (
+    obj &&
+    typeof obj === "object" &&
+    (obj.constructor.name === "InlineFile" || obj.constructor.name === "File")
+  );
+}
+
+function isDuration(obj) {
+  return obj && typeof obj === "object" && obj.constructor.name === "Duration";
+}
+
+export function parseOutputs(data) {
+  if (!data) {
+    return null;
+  }
+
+  if (!isPlainObject(data)) {
+    return data;
+  }
+
+  const keys = data ? Object.keys(data) : [];
+  const row = {};
+
+  for (const key of keys) {
+    const value = data[key];
+
+    if (isPlainObject(value)) {
+      if (value.key && value.size && value.filename && value.contentType) {
+        row[key] = File.fromDbRecord(value);
+      } else {
+        row[key] = parseOutputs(value);
+      }
+    } else if (
+      Array.isArray(value) &&
+      value.every((item) => typeof item === "object" && item !== null)
+    ) {
+      const arr = [];
+      for (let item of value) {
+        if (item.key && item.size && item.filename && item.contentType) {
+          arr.push(File.fromDbRecord(item));
+        } else {
+          arr.push(parseOutputs(item));
+        }
+      }
+      row[key] = arr;
+    } else {
+      row[key] = value;
+    }
+  }
+  return row;
+}
+
+function isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+}
+
+const dateFormat =
+  /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+
+export function reviver(key, value) {
+  // Handle date strings
+  if (typeof value === "string") {
+    if (dateFormat.test(value)) {
+      return new Date(value);
+    }
+  }
+
+  // Handle nested objects
+  if (value !== null && typeof value === "object") {
+    // Handle arrays
+    if (Array.isArray(value)) {
+      return value.map((item) => {
+        if (typeof item === "string") {
+          if (dateFormat.test(item)) {
+            return new Date(item);
+          }
+        }
+        return item;
+      });
+    }
+
+    // Handle plain objects
+    for (const k in value) {
+      if (typeof value[k] === "string") {
+        if (dateFormat.test(value[k])) {
+          value[k] = new Date(value[k]);
+        }
+      }
+    }
+  }
+
+  return value;
+}