@teamkeel/functions-runtime 0.411.0 → 0.412.0-next.1

package/dist/index.js

@@ -0,0 +1,3093 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/auditing.js
+var require_auditing = __commonJS({
+  "src/auditing.js"(exports2, module2) {
+    "use strict";
+    var { AsyncLocalStorage } = require("async_hooks");
+    var TraceParent = require("traceparent");
+    var { sql, SelectionNode } = require("kysely");
+    var auditContextStorage = new AsyncLocalStorage();
+    async function withAuditContext(request, cb) {
+      var _a, _b, _c, _d;
+      let audit = {};
+      if ((_a = request.meta) == null ? void 0 : _a.identity) {
+        audit.identityId = request.meta.identity.id;
+      }
+      if ((_c = (_b = request.meta) == null ? void 0 : _b.tracing) == null ? void 0 : _c.traceparent) {
+        audit.traceId = (_d = TraceParent.fromString(
+          request.meta.tracing.traceparent
+        )) == null ? void 0 : _d.traceId;
+      }
+      return await auditContextStorage.run(audit, () => {
+        return cb();
+      });
+    }
+    __name(withAuditContext, "withAuditContext");
+    function getAuditContext() {
+      let auditStore = auditContextStorage.getStore();
+      return {
+        identityId: auditStore == null ? void 0 : auditStore.identityId,
+        traceId: auditStore == null ? void 0 : auditStore.traceId
+      };
+    }
+    __name(getAuditContext, "getAuditContext");
+    var _AuditContextPlugin = 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":
+            const returning = {
+              kind: "ReturningNode",
+              selections: []
+            };
+            if (args.node.returning) {
+              returning.selections.push(...args.node.returning.selections);
+            }
+            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
+            };
+        }
+        return {
+          ...args.node
+        };
+      }
+      // Drops the set_identity_id() and set_trace_id() fields from the result.
+      transformResult(args) {
+        var _a;
+        if ((_a = args.result) == null ? void 0 : _a.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;
+      }
+    };
+    __name(_AuditContextPlugin, "AuditContextPlugin");
+    var AuditContextPlugin = _AuditContextPlugin;
+    module2.exports.withAuditContext = withAuditContext;
+    module2.exports.getAuditContext = getAuditContext;
+    module2.exports.AuditContextPlugin = AuditContextPlugin;
+  }
+});
+
+// src/Duration.js
+var require_Duration = __commonJS({
+  "src/Duration.js"(exports2, module2) {
+    "use strict";
+    var parseInterval = require("postgres-interval");
+    var isoRegex = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+    var _Duration = class _Duration {
+      constructor(postgresString) {
+        this._typename = "Duration";
+        this.pgInterval = postgresString;
+        this._interval = parseInterval(postgresString);
+      }
+      static fromISOString(isoString) {
+        const match = isoString.match(isoRegex);
+        if (match) {
+          let d = new _Duration();
+          d._interval.years = match[1];
+          d._interval.months = match[2];
+          d._interval.days = match[3];
+          d._interval.hours = match[4];
+          d._interval.minutes = match[5];
+          d._interval.seconds = match[6];
+          return d;
+        }
+        return new _Duration();
+      }
+      toISOString() {
+        return this._interval.toISOStringShort();
+      }
+      toPostgres() {
+        return this._interval.toPostgres();
+      }
+    };
+    __name(_Duration, "Duration");
+    var Duration = _Duration;
+    module2.exports = {
+      Duration
+    };
+  }
+});
+
+// src/type-utils.js
+var require_type_utils = __commonJS({
+  "src/type-utils.js"(exports2, module2) {
+    "use strict";
+    var { Duration } = require_Duration();
+    function isPlainObject(obj) {
+      return Object.prototype.toString.call(obj) === "[object Object]";
+    }
+    __name(isPlainObject, "isPlainObject");
+    function isRichType(obj) {
+      if (!isPlainObject(obj)) {
+        return false;
+      }
+      return obj instanceof Duration;
+    }
+    __name(isRichType, "isRichType");
+    module2.exports = {
+      isPlainObject,
+      isRichType
+    };
+  }
+});
+
+// src/camelCasePlugin.js
+var require_camelCasePlugin = __commonJS({
+  "src/camelCasePlugin.js"(exports2, module2) {
+    "use strict";
+    var { CamelCasePlugin } = require("kysely");
+    var { isPlainObject, isRichType } = require_type_utils();
+    var _KeelCamelCasePlugin = 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) => {
+          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;
+        }, {});
+      }
+    };
+    __name(_KeelCamelCasePlugin, "KeelCamelCasePlugin");
+    var KeelCamelCasePlugin = _KeelCamelCasePlugin;
+    function canMap(obj, opt) {
+      return isPlainObject(obj) && !(opt == null ? void 0 : opt.maintainNestedObjectKeys) && !isRichType(obj);
+    }
+    __name(canMap, "canMap");
+    module2.exports.KeelCamelCasePlugin = KeelCamelCasePlugin;
+  }
+});
+
+// src/tracing.js
+var require_tracing = __commonJS({
+  "src/tracing.js"(exports2, module2) {
+    "use strict";
+    var opentelemetry = require("@opentelemetry/api");
+    var { BatchSpanProcessor } = require("@opentelemetry/sdk-trace-base");
+    var {
+      OTLPTraceExporter
+    } = require("@opentelemetry/exporter-trace-otlp-proto");
+    var { NodeTracerProvider } = require("@opentelemetry/sdk-trace-node");
+    var { envDetectorSync } = require("@opentelemetry/resources");
+    async function withSpan(name, fn) {
+      return getTracer().startActiveSpan(name, async (span) => {
+        try {
+          return await fn(span);
+        } catch (err) {
+          span.recordException(err);
+          span.setStatus({
+            code: opentelemetry.SpanStatusCode.ERROR,
+            message: err.message
+          });
+          throw err;
+        } finally {
+          span.end();
+        }
+      });
+    }
+    __name(withSpan, "withSpan");
+    function patchFetch() {
+      if (!globalThis.fetch.patched) {
+        const originalFetch = globalThis.fetch;
+        globalThis.fetch = async (...args) => {
+          return withSpan("fetch", async (span) => {
+            const url = new URL(
+              args[0] instanceof Request ? args[0].url : String(args[0])
+            );
+            span.setAttribute("http.url", url.toString());
+            const scheme = url.protocol.replace(":", "");
+            span.setAttribute("http.scheme", scheme);
+            const options = args[0] instanceof Request ? args[0] : args[1] || {};
+            const method = (options.method || "GET").toUpperCase();
+            span.setAttribute("http.method", method);
+            const res = await originalFetch(...args);
+            span.setAttribute("http.status", res.status);
+            span.setAttribute("http.status_text", res.statusText);
+            return res;
+          });
+        };
+        globalThis.fetch.patched = true;
+      }
+    }
+    __name(patchFetch, "patchFetch");
+    function patchConsoleLog() {
+      if (!console.log.patched) {
+        const originalConsoleLog = console.log;
+        console.log = (...args) => {
+          const span = opentelemetry.trace.getActiveSpan();
+          if (span) {
+            const output = args.map((arg) => {
+              if (arg instanceof Error) {
+                return arg.stack;
+              }
+              if (typeof arg === "object") {
+                try {
+                  return JSON.stringify(arg, getCircularReplacer());
+                } catch (error) {
+                  return "[Object with circular references]";
+                }
+              }
+              if (typeof arg === "function") {
+                return arg() || arg.name || arg.toString();
+              }
+              return String(arg);
+            }).join(" ");
+            span.addEvent(output);
+          }
+          originalConsoleLog(...args);
+        };
+        console.log.patched = true;
+      }
+    }
+    __name(patchConsoleLog, "patchConsoleLog");
+    function patchConsoleError() {
+      if (!console.error.patched) {
+        const originalConsoleError = console.error;
+        console.error = (...args) => {
+          const span = opentelemetry.trace.getActiveSpan();
+          if (span) {
+            const output = args.map((arg) => {
+              if (arg instanceof Error) {
+                return arg.stack;
+              }
+              if (typeof arg === "object") {
+                try {
+                  return JSON.stringify(arg, getCircularReplacer());
+                } catch (error) {
+                  return "[Object with circular references]";
+                }
+              }
+              if (typeof arg === "function") {
+                return arg() || arg.name || arg.toString();
+              }
+              return String(arg);
+            }).join(" ");
+            span.setStatus({
+              code: opentelemetry.SpanStatusCode.ERROR,
+              message: output
+            });
+          }
+          originalConsoleError(...args);
+        };
+        console.error.patched = true;
+      }
+    }
+    __name(patchConsoleError, "patchConsoleError");
+    function getCircularReplacer() {
+      const seen = /* @__PURE__ */ new WeakSet();
+      return (key, value) => {
+        if (typeof value === "object" && value !== null) {
+          if (seen.has(value)) {
+            return "[Circular]";
+          }
+          seen.add(value);
+        }
+        return value;
+      };
+    }
+    __name(getCircularReplacer, "getCircularReplacer");
+    function init() {
+      if (process.env.KEEL_TRACING_ENABLED == "true") {
+        const exporter = new OTLPTraceExporter();
+        const processor = new BatchSpanProcessor(exporter);
+        const provider = new NodeTracerProvider({
+          resource: envDetectorSync.detect(),
+          spanProcessors: [processor]
+        });
+        provider.register();
+      }
+      patchFetch();
+      patchConsoleLog();
+      patchConsoleError();
+    }
+    __name(init, "init");
+    async function forceFlush() {
+      const provider = opentelemetry.trace.getTracerProvider().getDelegate();
+      if (provider && provider.forceFlush) {
+        await provider.forceFlush();
+      }
+    }
+    __name(forceFlush, "forceFlush");
+    function getTracer() {
+      return opentelemetry.trace.getTracer("functions");
+    }
+    __name(getTracer, "getTracer");
+    function spanNameForModelAPI(modelName, action) {
+      return `Database ${modelName}.${action}`;
+    }
+    __name(spanNameForModelAPI, "spanNameForModelAPI");
+    module2.exports = {
+      getTracer,
+      withSpan,
+      init,
+      forceFlush,
+      spanNameForModelAPI
+    };
+  }
+});
+
+// src/database.js
+var require_database = __commonJS({
+  "src/database.js"(exports2, module2) {
+    "use strict";
+    var { Kysely, PostgresDialect } = require("kysely");
+    var neonserverless = require("@neondatabase/serverless");
+    var { AsyncLocalStorage } = require("async_hooks");
+    var { AuditContextPlugin } = require_auditing();
+    var { KeelCamelCasePlugin } = require_camelCasePlugin();
+    var pg = require("pg");
+    var { withSpan } = require_tracing();
+    var ws = require("ws");
+    var fs = require("fs");
+    var { Duration } = require_Duration();
+    async function withDatabase(db, requiresTransaction, cb) {
+      if (requiresTransaction) {
+        return db.transaction().execute(async (transaction) => {
+          return dbInstance.run(transaction, async () => {
+            return cb({ transaction });
+          });
+        });
+      }
+      return db.connection().execute(async (sDb) => {
+        return dbInstance.run(sDb, async () => {
+          return cb({ sDb });
+        });
+      });
+    }
+    __name(withDatabase, "withDatabase");
+    var dbInstance = new AsyncLocalStorage();
+    var vitestDb = null;
+    function useDatabase2() {
+      let fromStore = dbInstance.getStore();
+      if (fromStore) {
+        return fromStore;
+      }
+      if ("NODE_ENV" in process.env && process.env.NODE_ENV == "test") {
+        if (!vitestDb) {
+          vitestDb = createDatabaseClient();
+        }
+        return vitestDb;
+      }
+      console.trace();
+      throw new Error("useDatabase must be called within a function");
+    }
+    __name(useDatabase2, "useDatabase");
+    function createDatabaseClient({ connString } = {}) {
+      const db = new Kysely({
+        dialect: getDialect(connString),
+        plugins: [
+          // ensures that the audit context data is written to Postgres configuration parameters
+          new AuditContextPlugin(),
+          // allows users to query using camelCased versions of the database column names, which
+          // should match the names we use in our schema.
+          // We're using an extended version of Kysely's CamelCasePlugin which avoids changing keys of objects that represent
+          // rich data formats, specific to Keel (e.g. Duration)
+          new KeelCamelCasePlugin()
+        ],
+        log(event) {
+          if ("DEBUG" in process.env) {
+            if (event.level === "query") {
+              console.log(event.query.sql);
+              console.log(event.query.parameters);
+            }
+          }
+        }
+      });
+      return db;
+    }
+    __name(createDatabaseClient, "createDatabaseClient");
+    var _InstrumentedPool = class _InstrumentedPool extends pg.Pool {
+      async connect(...args) {
+        const _super = super.connect.bind(this);
+        return withSpan("Database Connect", function(span) {
+          span.setAttribute("dialect", process.env["KEEL_DB_CONN_TYPE"]);
+          return _super(...args);
+        });
+      }
+    };
+    __name(_InstrumentedPool, "InstrumentedPool");
+    var InstrumentedPool = _InstrumentedPool;
+    var _InstrumentedNeonServerlessPool = class _InstrumentedNeonServerlessPool extends neonserverless.Pool {
+      async connect(...args) {
+        const _super = super.connect.bind(this);
+        return withSpan("Database Connect", function(span) {
+          span.setAttribute("dialect", process.env["KEEL_DB_CONN_TYPE"]);
+          return _super(...args);
+        });
+      }
+    };
+    __name(_InstrumentedNeonServerlessPool, "InstrumentedNeonServerlessPool");
+    var InstrumentedNeonServerlessPool = _InstrumentedNeonServerlessPool;
+    var txStatements = {
+      begin: "Transaction Begin",
+      commit: "Transaction Commit",
+      rollback: "Transaction Rollback"
+    };
+    var _InstrumentedClient = class _InstrumentedClient extends pg.Client {
+      async query(...args) {
+        const _super = super.query.bind(this);
+        const sql = args[0];
+        let sqlAttribute = false;
+        let spanName = txStatements[sql.toLowerCase()];
+        if (!spanName) {
+          spanName = "Database Query";
+          sqlAttribute = true;
+        }
+        return withSpan(spanName, function(span) {
+          if (sqlAttribute) {
+            span.setAttribute("sql", args[0]);
+            span.setAttribute("dialect", process.env["KEEL_DB_CONN_TYPE"]);
+          }
+          return _super(...args);
+        });
+      }
+    };
+    __name(_InstrumentedClient, "InstrumentedClient");
+    var InstrumentedClient = _InstrumentedClient;
+    function getDialect(connString) {
+      const dbConnType = process.env.KEEL_DB_CONN_TYPE;
+      switch (dbConnType) {
+        case "pg":
+          pg.types.setTypeParser(pg.types.builtins.NUMERIC, function(val) {
+            return parseFloat(val);
+          });
+          pg.types.setTypeParser(pg.types.builtins.INTERVAL, function(val) {
+            return new Duration(val);
+          });
+          return new PostgresDialect({
+            pool: new InstrumentedPool({
+              Client: InstrumentedClient,
+              // Increased idle time before closing a connection in the local pool (from 10s default).
+              // Establising a new connection on (almost) every functions query can be expensive, so this
+              // will reduce having to open connections as regularly. https://node-postgres.com/apis/pool
+              //
+              // NOTE: We should consider setting this to 0 (i.e. never pool locally) and open and close
+              // connections with each invocation. This is because the freeze/thaw nature of lambdas can cause problems
+              // with long-lived connections - see https://github.com/brianc/node-postgres/issues/2718
+              // Once we're "fully regional" this should not be a performance problem anymore.
+              //
+              // Although I doubt we will run into these freeze/thaw issues if idleTimeoutMillis is always shorter than the
+              // time is takes for a lambda to freeze (which is not a constant, but could be as short as several minutes,
+              // https://www.pluralsight.com/resources/blog/cloud/how-long-does-aws-lambda-keep-your-idle-functions-around-before-a-cold-start)
+              idleTimeoutMillis: 5e4,
+              // If connString is not passed fall back to reading from env var
+              connectionString: connString || process.env.KEEL_DB_CONN,
+              // Allow the setting of a cert (.pem) file. RDS requires this to enforce SSL.
+              ...process.env.KEEL_DB_CERT ? { ssl: { ca: fs.readFileSync(process.env.KEEL_DB_CERT) } } : void 0
+            })
+          });
+        case "neon":
+          neonserverless.types.setTypeParser(
+            pg.types.builtins.NUMERIC,
+            function(val) {
+              return parseFloat(val);
+            }
+          );
+          neonserverless.types.setTypeParser(
+            pg.types.builtins.INTERVAL,
+            function(val) {
+              return new Duration(val);
+            }
+          );
+          neonserverless.neonConfig.webSocketConstructor = ws;
+          const pool = new InstrumentedNeonServerlessPool({
+            // If connString is not passed fall back to reading from env var
+            connectionString: connString || process.env.KEEL_DB_CONN
+          });
+          pool.on("connect", (client) => {
+            const originalQuery = client.query;
+            client.query = function(...args) {
+              const sql = args[0];
+              let sqlAttribute = false;
+              let spanName = txStatements[sql.toLowerCase()];
+              if (!spanName) {
+                spanName = "Database Query";
+                sqlAttribute = true;
+              }
+              return withSpan(spanName, function(span) {
+                if (sqlAttribute) {
+                  span.setAttribute("sql", args[0]);
+                  span.setAttribute("dialect", dbConnType);
+                }
+                return originalQuery.apply(client, args);
+              });
+            };
+          });
+          return new PostgresDialect({
+            pool
+          });
+        default:
+          throw Error("unexpected KEEL_DB_CONN_TYPE: " + dbConnType);
+      }
+    }
+    __name(getDialect, "getDialect");
+    module2.exports = {
+      createDatabaseClient,
+      useDatabase: useDatabase2,
+      withDatabase
+    };
+  }
+});
+
+// src/errors.js
+var require_errors = __commonJS({
+  "src/errors.js"(exports2, module2) {
+    "use strict";
+    var { createJSONRPCErrorResponse } = require("json-rpc-2.0");
+    var RuntimeErrors = {
+      // Catchall error type for unhandled execution errors during custom function
+      UnknownError: -32001,
+      // DatabaseError represents any error at pg level that isn't handled explicitly below
+      DatabaseError: -32002,
+      // No result returned from custom function by user
+      NoResultError: -32003,
+      // When trying to delete/update a non existent record in the db
+      RecordNotFoundError: -32004,
+      ForeignKeyConstraintError: -32005,
+      NotNullConstraintError: -32006,
+      UniqueConstraintError: -32007,
+      PermissionError: -32008,
+      BadRequestError: -32009
+    };
+    var _PermissionError = class _PermissionError extends Error {
+    };
+    __name(_PermissionError, "PermissionError");
+    var PermissionError = _PermissionError;
+    var _DatabaseError = class _DatabaseError extends Error {
+      constructor(error) {
+        super(error.message);
+        this.error = error;
+      }
+    };
+    __name(_DatabaseError, "DatabaseError");
+    var DatabaseError = _DatabaseError;
+    var _NotFoundError = class _NotFoundError extends Error {
+      errorCode = RuntimeErrors.RecordNotFoundError;
+      constructor(message) {
+        super(message);
+      }
+    };
+    __name(_NotFoundError, "NotFoundError");
+    var NotFoundError = _NotFoundError;
+    var _BadRequestError = class _BadRequestError extends Error {
+      errorCode = RuntimeErrors.BadRequestError;
+      constructor(message = "bad request") {
+        super(message);
+      }
+    };
+    __name(_BadRequestError, "BadRequestError");
+    var BadRequestError = _BadRequestError;
+    var _UnknownError = class _UnknownError extends Error {
+      errorCode = RuntimeErrors.UnknownError;
+      constructor(message = "unknown error") {
+        super(message);
+      }
+    };
+    __name(_UnknownError, "UnknownError");
+    var UnknownError = _UnknownError;
+    var ErrorPresets = {
+      NotFound: NotFoundError,
+      BadRequest: BadRequestError,
+      Unknown: UnknownError
+    };
+    function errorToJSONRPCResponse(request, e) {
+      switch (e.constructor.name) {
+        case "PermissionError":
+          return createJSONRPCErrorResponse(
+            request.id,
+            RuntimeErrors.PermissionError,
+            e.message
+          );
+        // Any error thrown in the ModelAPI class is
+        // wrapped in a DatabaseError in order to differentiate 'our code' vs the user's own code.
+        case "NoResultError":
+          return createJSONRPCErrorResponse(
+            request.id,
+            // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
+            RuntimeErrors.RecordNotFoundError,
+            ""
+            // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
+          );
+        case "DatabaseError":
+          let err = e;
+          if (e instanceof DatabaseError) {
+            err = e.error;
+          }
+          if (err.constructor.name == "NoResultError") {
+            return createJSONRPCErrorResponse(
+              request.id,
+              // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
+              RuntimeErrors.RecordNotFoundError,
+              ""
+              // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
+            );
+          }
+          if ("code" in err) {
+            const { code, detail, table: table2 } = err;
+            let rpcErrorCode, column, value;
+            const [col, val] = parseKeyMessage(err.detail);
+            column = col;
+            value = val;
+            switch (code) {
+              case "23502":
+                rpcErrorCode = RuntimeErrors.NotNullConstraintError;
+                column = err.column;
+                break;
+              case "23503":
+                rpcErrorCode = RuntimeErrors.ForeignKeyConstraintError;
+                break;
+              case "23505":
+                rpcErrorCode = RuntimeErrors.UniqueConstraintError;
+                break;
+              default:
+                rpcErrorCode = RuntimeErrors.DatabaseError;
+                break;
+            }
+            return createJSONRPCErrorResponse(request.id, rpcErrorCode, e.message, {
+              table: table2,
+              column,
+              code,
+              detail,
+              value
+            });
+          }
+          return createJSONRPCErrorResponse(
+            request.id,
+            RuntimeErrors.DatabaseError,
+            e.message
+          );
+        default:
+          return createJSONRPCErrorResponse(
+            request.id,
+            e.errorCode ?? RuntimeErrors.UnknownError,
+            e.message
+          );
+      }
+    }
+    __name(errorToJSONRPCResponse, "errorToJSONRPCResponse");
+    var keyMessagePattern = /\Key\s[(](.*)[)][=][(](.*)[)]/;
+    var parseKeyMessage = /* @__PURE__ */ __name((msg) => {
+      const [, col, value] = keyMessagePattern.exec(msg) || [];
+      return [col, value];
+    }, "parseKeyMessage");
+    module2.exports = {
+      errorToJSONRPCResponse,
+      RuntimeErrors,
+      DatabaseError,
+      PermissionError,
+      ErrorPresets
+    };
+  }
+});
+
+// src/File.js
+var require_File = __commonJS({
+  "src/File.js"(exports2, module2) {
+    "use strict";
+    var {
+      S3Client,
+      PutObjectCommand,
+      GetObjectCommand
+    } = require("@aws-sdk/client-s3");
+    var { fromEnv } = require("@aws-sdk/credential-providers");
+    var { getSignedUrl } = require("@aws-sdk/s3-request-presigner");
+    var { useDatabase: useDatabase2 } = require_database();
+    var { DatabaseError } = require_errors();
+    var KSUID = require("ksuid");
+    var s3Client = (() => {
+      if (!process.env.KEEL_FILES_BUCKET_NAME) {
+        return null;
+      }
+      const endpoint = process.env.TEST_AWS_ENDPOINT;
+      if (!endpoint) {
+        return new S3Client({
+          region: process.env.KEEL_REGION,
+          credentials: fromEnv()
+        });
+      }
+      return new S3Client({
+        region: process.env.KEEL_REGION,
+        // If a test endpoint is provided then use some test credentials
+        credentials: {
+          accessKeyId: "test",
+          secretAccessKey: "test"
+        },
+        // If a custom endpoint is set we need to use a custom resolver. Just setting the base endpoint isn't enough for S3 as it
+        // as the default resolver uses the bucket name as a sub-domain, which likely won't work with the custom endpoint.
+        // By implementing a full resolver we can force it to be the endpoint we want.
+        endpointProvider: /* @__PURE__ */ __name(() => {
+          return {
+            url: new URL(endpoint)
+          };
+        }, "endpointProvider")
+      });
+    })();
+    var _InlineFile = class _InlineFile {
+      constructor({ filename, contentType }) {
+        this._filename = filename;
+        this._contentType = contentType;
+        this._contents = null;
+      }
+      static fromDataURL(dataURL) {
+        var info = dataURL.split(",")[0].split(":")[1];
+        var data = dataURL.split(",")[1];
+        var mime = info.split(";")[0];
+        var name = info.split(";")[1].split("=")[1];
+        var buffer = Buffer.from(data, "base64");
+        var file = new _InlineFile({ filename: name, contentType: mime });
+        file.write(buffer);
+        return file;
+      }
+      get size() {
+        if (this._contents) {
+          return this._contents.size;
+        } else {
+          return 0;
+        }
+      }
+      get contentType() {
+        return this._contentType;
+      }
+      get filename() {
+        return this._filename;
+      }
+      write(buffer) {
+        this._contents = new Blob([buffer]);
+      }
+      // Read the contents of the file. If URL is set, it will be read from the remote storage, otherwise, if dataURL is set
+      // on the instance, it will return a blob with the file contents
+      async read() {
+        const arrayBuffer = await this._contents.arrayBuffer();
+        const buffer = Buffer.from(arrayBuffer);
+        return buffer;
+      }
+      async store(expires = null) {
+        const content = await this.read();
+        const key = KSUID.randomSync().string;
+        await storeFile(
+          content,
+          key,
+          this._filename,
+          this._contentType,
+          this.size,
+          expires
+        );
+        return new File({
+          key,
+          size: this.size,
+          filename: this.filename,
+          contentType: this.contentType
+        });
+      }
+    };
+    __name(_InlineFile, "InlineFile");
+    var InlineFile = _InlineFile;
+    var _File = class _File extends InlineFile {
+      constructor(input) {
+        super({ filename: input.filename, contentType: input.contentType });
+        this._key = input.key;
+        this._size = input.size;
+      }
+      static fromDbRecord({ key, filename, size, contentType }) {
+        return new _File({
+          key,
+          filename,
+          size,
+          contentType
+        });
+      }
+      get size() {
+        return this._size;
+      }
+      get key() {
+        return this._key;
+      }
+      async read() {
+        if (this._contents) {
+          const arrayBuffer = await this._contents.arrayBuffer();
+          return Buffer.from(arrayBuffer);
+        }
+        if (s3Client) {
+          const params = {
+            Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+            Key: "files/" + this.key
+          };
+          const command = new GetObjectCommand(params);
+          const response = await s3Client.send(command);
+          const blob = await response.Body.transformToByteArray();
+          return Buffer.from(blob);
+        }
+        const db = useDatabase2();
+        try {
+          let query = db.selectFrom("keel_storage").select("data").where("id", "=", this.key);
+          const row = await query.executeTakeFirstOrThrow();
+          return row.data;
+        } catch (e) {
+          throw new DatabaseError(e);
+        }
+      }
+      async store(expires = null) {
+        if (this._contents) {
+          const contents = await this.read();
+          await storeFile(
+            contents,
+            this.key,
+            this.filename,
+            this.contentType,
+            expires
+          );
+        }
+        return this;
+      }
+      async getPresignedUrl() {
+        if (s3Client) {
+          const command = new GetObjectCommand({
+            Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+            Key: "files/" + this.key,
+            ResponseContentDisposition: "inline"
+          });
+          const url = await getSignedUrl(s3Client, command, { expiresIn: 60 * 60 });
+          return new URL(url);
+        } else {
+          const contents = await this.read();
+          const dataurl = `data:${this.contentType};name=${this.filename};base64,${contents.toString("base64")}`;
+          return new URL(dataurl);
+        }
+      }
+      toDbRecord() {
+        return {
+          key: this.key,
+          filename: this.filename,
+          contentType: this.contentType,
+          size: this.size
+        };
+      }
+      toJSON() {
+        return {
+          key: this.key,
+          filename: this.filename,
+          contentType: this.contentType,
+          size: this.size
+        };
+      }
+    };
+    __name(_File, "File");
+    var File = _File;
+    async function storeFile(contents, key, filename, contentType, expires) {
+      if (s3Client) {
+        const params = {
+          Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+          Key: "files/" + key,
+          Body: contents,
+          ContentType: contentType,
+          ContentDisposition: `attachment; filename="${encodeURIComponent(
+            filename
+          )}"`,
+          Metadata: {
+            filename
+          },
+          ACL: "private"
+        };
+        if (expires) {
+          if (expires instanceof Date) {
+            params.Expires = expires;
+          } else {
+            console.warn("Invalid expires value. Skipping Expires parameter.");
+          }
+        }
+        const command = new PutObjectCommand(params);
+        try {
+          await s3Client.send(command);
+        } catch (error) {
+          console.error("Error uploading file:", error);
+          throw error;
+        }
+      } else {
+        const db = useDatabase2();
+        try {
+          let query = db.insertInto("keel_storage").values({
+            id: key,
+            filename,
+            content_type: contentType,
+            data: contents
+          }).onConflict(
+            (oc) => oc.column("id").doUpdateSet(() => ({
+              filename,
+              content_type: contentType,
+              data: contents
+            })).where("keel_storage.id", "=", key)
+          ).returningAll();
+          await query.execute();
+        } catch (e) {
+          throw new DatabaseError(e);
+        }
+      }
+    }
+    __name(storeFile, "storeFile");
+    module2.exports = {
+      InlineFile,
+      File
+    };
+  }
+});
+
+// src/parsing.js
+var require_parsing = __commonJS({
+  "src/parsing.js"(exports2, module2) {
+    "use strict";
+    var { Duration } = require_Duration();
+    var { InlineFile, File } = require_File();
+    var { isPlainObject } = require_type_utils();
+    function parseInputs(inputs) {
+      if (inputs != null && typeof inputs === "object") {
+        for (const k of Object.keys(inputs)) {
+          if (inputs[k] !== null && typeof inputs[k] === "object") {
+            if (Array.isArray(inputs[k])) {
+              inputs[k] = inputs[k].map((item) => {
+                if (item && typeof item === "object") {
+                  if ("__typename" in item) {
+                    return parseComplexInputType(item);
+                  }
+                  return parseInputs(item);
+                }
+                return item;
+              });
+            } else if ("__typename" in inputs[k]) {
+              inputs[k] = parseComplexInputType(inputs[k]);
+            } else {
+              inputs[k] = parseInputs(inputs[k]);
+            }
+          }
+        }
+      }
+      return inputs;
+    }
+    __name(parseInputs, "parseInputs");
+    function parseComplexInputType(value) {
+      switch (value.__typename) {
+        case "InlineFile":
+          return InlineFile.fromDataURL(value.dataURL);
+        case "Duration":
+          return Duration.fromISOString(value.interval);
+        default:
+          throw new Error("complex type not handled: " + value.__typename);
+      }
+    }
+    __name(parseComplexInputType, "parseComplexInputType");
+    async function parseOutputs(outputs) {
+      if (outputs != null && typeof outputs === "object") {
+        for (const k of Object.keys(outputs)) {
+          if (outputs[k] !== null && typeof outputs[k] === "object") {
+            if (Array.isArray(outputs[k])) {
+              outputs[k] = await Promise.all(
+                outputs[k].map((item) => parseOutputs(item))
+              );
+            } else if (outputs[k] instanceof InlineFile) {
+              const stored = await outputs[k].store();
+              outputs[k] = stored;
+            } else if (outputs[k] instanceof Duration) {
+              outputs[k] = outputs[k].toISOString();
+            } else {
+              outputs[k] = await parseOutputs(outputs[k]);
+            }
+          }
+        }
+      }
+      return outputs;
+    }
+    __name(parseOutputs, "parseOutputs");
+    function transformRichDataTypes(data) {
+      const keys = data ? Object.keys(data) : [];
+      const row = {};
+      for (const key of keys) {
+        const value = data[key];
+        if (Array.isArray(value)) {
+          row[key] = value.map((item) => transformRichDataTypes({ item }).item);
+        } else if (isPlainObject(value)) {
+          if (value._typename == "Duration" && value.pgInterval) {
+            row[key] = new Duration(value.pgInterval);
+          } else if (value.key && value.size && value.filename && value.contentType) {
+            row[key] = File.fromDbRecord(value);
+          } else {
+            row[key] = value;
+          }
+        } else {
+          row[key] = value;
+        }
+      }
+      return row;
+    }
+    __name(transformRichDataTypes, "transformRichDataTypes");
+    function isReferencingExistingRecord(value) {
+      return Object.keys(value).length === 1 && value.id;
+    }
+    __name(isReferencingExistingRecord, "isReferencingExistingRecord");
+    module2.exports = {
+      parseInputs,
+      parseOutputs,
+      transformRichDataTypes,
+      isReferencingExistingRecord
+    };
+  }
+});
+
+// src/casing.js
+var require_casing = __commonJS({
+  "src/casing.js"(exports2, module2) {
+    "use strict";
+    var { 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;
+    }
+    __name(camelCaseObject, "camelCaseObject");
+    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;
+    }
+    __name(snakeCaseObject, "snakeCaseObject");
+    function upperCamelCase(s) {
+      s = camelCase(s);
+      return s[0].toUpperCase() + s.substring(1);
+    }
+    __name(upperCamelCase, "upperCamelCase");
+    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}`;
+    }
+    __name(camelCaseTransform, "camelCaseTransform");
+    module2.exports = {
+      camelCaseObject,
+      snakeCaseObject,
+      snakeCase,
+      camelCase,
+      upperCamelCase
+    };
+  }
+});
+
+// src/TimePeriod.js
+var require_TimePeriod = __commonJS({
+  "src/TimePeriod.js"(exports2, module2) {
+    "use strict";
+    var _TimePeriod = class _TimePeriod {
+      constructor(period = "", value = 0, offset = 0, complete = false) {
+        this.period = period;
+        this.value = value;
+        this.offset = offset;
+        this.complete = complete;
+      }
+      static fromExpression(expression) {
+        const pattern = /^(this|next|last)?\s*(\d+)?\s*(complete)?\s*(second|minute|hour|day|week|month|year|seconds|minutes|hours|days|weeks|months|years)?$/i;
+        const shorthandPattern = /^(now|today|tomorrow|yesterday)$/i;
+        const shorthandMatch = shorthandPattern.exec(expression.trim());
+        if (shorthandMatch) {
+          const shorthand = shorthandMatch[1].toLowerCase();
+          switch (shorthand) {
+            case "now":
+              return new _TimePeriod();
+            case "today":
+              return _TimePeriod.fromExpression("this day");
+            case "tomorrow":
+              return _TimePeriod.fromExpression("next complete day");
+            case "yesterday":
+              return _TimePeriod.fromExpression("last complete day");
+          }
+        }
+        const match = pattern.exec(expression.trim());
+        if (!match) {
+          throw new Error("Invalid time period expression");
+        }
+        const [, direction, rawValue, isComplete, rawPeriod] = match;
+        let period = rawPeriod ? rawPeriod.toLowerCase().replace(/s$/, "") : "";
+        let value = rawValue ? parseInt(rawValue, 10) : 1;
+        let complete = Boolean(isComplete);
+        let offset = 0;
+        switch (direction == null ? void 0 : direction.toLowerCase()) {
+          case "this":
+            offset = 0;
+            complete = true;
+            break;
+          case "next":
+            offset = complete ? 1 : 0;
+            break;
+          case "last":
+            offset = -value;
+            break;
+          default:
+            throw new Error(
+              "Time period expression must start with this, next, or last"
+            );
+        }
+        return new _TimePeriod(period, value, offset, complete);
+      }
+      periodStartSQL() {
+        let sql = "NOW()";
+        if (this.offset !== 0) {
+          sql = `${sql} + INTERVAL '${this.offset} ${this.period}'`;
+        }
+        if (this.complete) {
+          sql = `DATE_TRUNC('${this.period}', ${sql})`;
+        } else {
+          sql = `(${sql})`;
+        }
+        return sql;
+      }
+      periodEndSQL() {
+        let sql = this.periodStartSQL();
+        if (this.value != 0) {
+          sql = `(${sql} + INTERVAL '${this.value} ${this.period}')`;
+        }
+        return sql;
+      }
+    };
+    __name(_TimePeriod, "TimePeriod");
+    var TimePeriod = _TimePeriod;
+    module2.exports = {
+      TimePeriod
+    };
+  }
+});
+
+// src/applyWhereConditions.js
+var require_applyWhereConditions = __commonJS({
+  "src/applyWhereConditions.js"(exports2, module2) {
+    "use strict";
+    var { sql, Kysely } = require("kysely");
+    var { snakeCase } = require_casing();
+    var { TimePeriod } = require_TimePeriod();
+    var opMapping = {
+      startsWith: { op: "like", value: /* @__PURE__ */ __name((v) => `${v}%`, "value") },
+      endsWith: { op: "like", value: /* @__PURE__ */ __name((v) => `%${v}`, "value") },
+      contains: { op: "like", value: /* @__PURE__ */ __name((v) => `%${v}%`, "value") },
+      oneOf: { op: "=", value: /* @__PURE__ */ __name((v) => sql`ANY(${v})`, "value") },
+      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: /* @__PURE__ */ __name((v) => sql`${sql.raw(
+          TimePeriod.fromExpression(v).periodStartSQL()
+        )} AND ${sql.raw(TimePeriod.fromExpression(v).periodEndSQL())}`, "value")
+      },
+      beforeRelative: {
+        op: "<",
+        value: /* @__PURE__ */ __name((v) => sql`${sql.raw(TimePeriod.fromExpression(v).periodStartSQL())}`, "value")
+      },
+      afterRelative: {
+        op: ">=",
+        value: /* @__PURE__ */ __name((v) => sql`${sql.raw(TimePeriod.fromExpression(v).periodEndSQL())}`, "value")
+      },
+      any: {
+        isArrayQuery: true,
+        greaterThan: { op: ">" },
+        greaterThanOrEquals: { op: ">=" },
+        lessThan: { op: "<" },
+        lessThanOrEquals: { op: "<=" },
+        before: { op: "<" },
+        onOrBefore: { op: "<=" },
+        after: { op: ">" },
+        onOrAfter: { op: ">=" },
+        equals: { op: "=" },
+        notEquals: { op: "=", value: /* @__PURE__ */ __name((v) => sql`NOT ${v}`, "value") }
+      },
+      all: {
+        isArrayQuery: true,
+        greaterThan: { op: ">" },
+        greaterThanOrEquals: { op: ">=" },
+        lessThan: { op: "<" },
+        lessThanOrEquals: { op: "<=" },
+        before: { op: "<" },
+        onOrBefore: { op: "<=" },
+        after: { op: ">" },
+        onOrAfter: { op: ">=" },
+        equals: { op: "=" },
+        notEquals: { op: "=", value: /* @__PURE__ */ __name((v) => sql`NOT ${v}`, "value") }
+      }
+    };
+    function applyWhereConditions(context, qb, where = {}) {
+      const conf = context.tableConfig();
+      for (const key of Object.keys(where)) {
+        const v = where[key];
+        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;
+    }
+    __name(applyWhereConditions, "applyWhereConditions");
+    module2.exports = {
+      applyWhereConditions
+    };
+  }
+});
+
+// src/applyAdditionalQueryConstraints.js
+var require_applyAdditionalQueryConstraints = __commonJS({
+  "src/applyAdditionalQueryConstraints.js"(exports2, module2) {
+    "use strict";
+    var { snakeCase } = require("change-case");
+    function applyLimit(context, qb, limit) {
+      return qb.limit(limit);
+    }
+    __name(applyLimit, "applyLimit");
+    function applyOffset(context, qb, offset) {
+      return qb.offset(offset);
+    }
+    __name(applyOffset, "applyOffset");
+    function applyOrderBy(context, qb, tableName, orderBy = {}) {
+      Object.entries(orderBy).forEach(([key, sortOrder]) => {
+        qb = qb.orderBy(`${tableName}.${snakeCase(key)}`, sortOrder.toLowerCase());
+      });
+      return qb;
+    }
+    __name(applyOrderBy, "applyOrderBy");
+    module2.exports = {
+      applyLimit,
+      applyOffset,
+      applyOrderBy
+    };
+  }
+});
+
+// src/applyJoins.js
+var require_applyJoins = __commonJS({
+  "src/applyJoins.js"(exports2, module2) {
+    "use strict";
+    var { snakeCase } = require_casing();
+    function applyJoins(context, qb, where) {
+      const conf = context.tableConfig();
+      if (!conf) {
+        return qb;
+      }
+      const srcTable = context.tableAlias();
+      for (const key of Object.keys(where)) {
+        const rel = conf[snakeCase(key)];
+        if (!rel) {
+          continue;
+        }
+        const targetTable = rel.referencesTable;
+        if (context.hasJoin(targetTable)) {
+          continue;
+        }
+        context.withJoin(targetTable, () => {
+          switch (rel.relationshipType) {
+            case "hasMany":
+              qb = qb.innerJoin(
+                `${targetTable} as ${context.tableAlias()}`,
+                `${srcTable}.id`,
+                `${context.tableAlias()}.${rel.foreignKey}`
+              );
+              break;
+            case "belongsTo":
+              qb = qb.innerJoin(
+                `${targetTable} as ${context.tableAlias()}`,
+                `${srcTable}.${rel.foreignKey}`,
+                `${context.tableAlias()}.id`
+              );
+              break;
+            default:
+              throw new Error(`unknown relationshipType: ${rel.relationshipType}`);
+          }
+          qb = applyJoins(context, qb, where[key]);
+        });
+      }
+      return qb;
+    }
+    __name(applyJoins, "applyJoins");
+    module2.exports = {
+      applyJoins
+    };
+  }
+});
+
+// src/QueryContext.js
+var require_QueryContext = __commonJS({
+  "src/QueryContext.js"(exports2, module2) {
+    "use strict";
+    var _QueryContext = class _QueryContext {
+      /**
+       * @param {string[]} tablePath This is the path from the "root" table to the "current table".
+       * @param {import("./ModelAPI").TableConfigMap} tableConfigMap
+       * @param {string[]} joins
+       */
+      constructor(tablePath, tableConfigMap, joins = []) {
+        this._tablePath = tablePath;
+        this._tableConfigMap = tableConfigMap;
+        this._joins = joins;
+      }
+      clone() {
+        return new _QueryContext([...this._tablePath], this._tableConfigMap, [
+          ...this._joins
+        ]);
+      }
+      /**
+       * Returns true if, given the current table path, a join to the given
+       * table has already been added.
+       * @param {string} table
+       * @returns {boolean}
+       */
+      hasJoin(table2) {
+        const alias = joinAlias([...this._tablePath, table2]);
+        return this._joins.includes(alias);
+      }
+      /**
+       * Adds table to the QueryContext's path and registers the join,
+       * calls fn, then pops the table off the path.
+       * @param {string} table
+       * @param {Function} fn
+       */
+      withJoin(table2, fn) {
+        this._tablePath.push(table2);
+        this._joins.push(this.tableAlias());
+        fn();
+        this._tablePath.pop();
+      }
+      /**
+       * Returns the alias that will be used for the current table
+       * @returns {string}
+       */
+      tableAlias() {
+        return joinAlias(this._tablePath);
+      }
+      /**
+       * Returns the current table name
+       * @returns {string}
+       */
+      tableName() {
+        return this._tablePath[this._tablePath.length - 1];
+      }
+      /**
+       * Return the TableConfig for the current table
+       * @returns {import("./ModelAPI").TableConfig | undefined}
+       */
+      tableConfig() {
+        return this._tableConfigMap[this.tableName()];
+      }
+    };
+    __name(_QueryContext, "QueryContext");
+    var QueryContext = _QueryContext;
+    function joinAlias(tablePath) {
+      return tablePath.join("$");
+    }
+    __name(joinAlias, "joinAlias");
+    module2.exports = {
+      QueryContext
+    };
+  }
+});
+
+// src/QueryBuilder.js
+var require_QueryBuilder = __commonJS({
+  "src/QueryBuilder.js"(exports2, module2) {
+    "use strict";
+    var { applyWhereConditions } = require_applyWhereConditions();
+    var {
+      applyLimit,
+      applyOffset,
+      applyOrderBy
+    } = require_applyAdditionalQueryConstraints();
+    var { applyJoins } = require_applyJoins();
+    var {
+      camelCaseObject,
+      snakeCaseObject,
+      upperCamelCase
+    } = require_casing();
+    var { useDatabase: useDatabase2 } = require_database();
+    var { transformRichDataTypes } = require_parsing();
+    var { QueryContext } = require_QueryContext();
+    var tracing = require_tracing();
+    var { DatabaseError } = require_errors();
+    var _QueryBuilder = class _QueryBuilder {
+      /**
+       * @param {string} tableName
+       * @param {import("./QueryContext").QueryContext} context
+       * @param {import("kysely").Kysely} db
+       */
+      constructor(tableName, context, db) {
+        this._tableName = tableName;
+        this._context = context;
+        this._db = db;
+        this._modelName = upperCamelCase(this._tableName);
+      }
+      where(where) {
+        const context = this._context.clone();
+        let builder = applyJoins(context, this._db, where);
+        builder = applyWhereConditions(context, builder, where);
+        return new _QueryBuilder(this._tableName, context, builder);
+      }
+      sql() {
+        return this._db.compile().sql;
+      }
+      async update(values) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "update");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          const sub = this._db.clearSelect().select("id");
+          const query = db.updateTable(this._tableName).set(snakeCaseObject(values)).returningAll().where("id", "in", sub);
+          try {
+            const result = await query.execute();
+            const numUpdatedRows = result.length;
+            if (numUpdatedRows == 0) {
+              return null;
+            }
+            if (numUpdatedRows > 1) {
+              throw new DatabaseError(
+                new Error(
+                  "more than one row matched update constraints - only unique fields should be used when updating."
+                )
+              );
+            }
+            return transformRichDataTypes(camelCaseObject(result[0]));
+          } catch (e) {
+            throw new DatabaseError(e);
+          }
+        });
+      }
+      async delete() {
+        const name = tracing.spanNameForModelAPI(this._modelName, "delete");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          const sub = this._db.clearSelect().select("id");
+          let builder = db.deleteFrom(this._tableName).where("id", "in", sub);
+          const query = builder.returning(["id"]);
+          span.setAttribute("sql", query.compile().sql);
+          try {
+            const row = await query.executeTakeFirstOrThrow();
+            return row.id;
+          } catch (e) {
+            throw new DatabaseError(e);
+          }
+        });
+      }
+      async findOne() {
+        const name = tracing.spanNameForModelAPI(this._modelName, "findOne");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          let builder = db.selectFrom((qb) => {
+            return this._db.as(this._tableName);
+          }).selectAll();
+          span.setAttribute("sql", builder.compile().sql);
+          const row = await builder.executeTakeFirst();
+          if (!row) {
+            return null;
+          }
+          return transformRichDataTypes(camelCaseObject(row));
+        });
+      }
+      async findMany(params) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "findMany");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          const context = new QueryContext([this._tableName], this._tableConfigMap);
+          let builder = db.selectFrom((qb) => {
+            return this._db.as(this._tableName);
+          }).selectAll();
+          if (params == null ? void 0 : params.limit) {
+            builder = applyLimit(context, builder, params.limit);
+          }
+          if (params == null ? void 0 : params.offset) {
+            builder = applyOffset(context, builder, params.offset);
+          }
+          if ((params == null ? void 0 : params.orderBy) !== void 0 && Object.keys(params == null ? void 0 : params.orderBy).length > 0) {
+            builder = applyOrderBy(
+              context,
+              builder,
+              this._tableName,
+              params.orderBy
+            );
+          } else {
+            builder = builder.orderBy(`${this._tableName}.id`);
+          }
+          const query = builder;
+          span.setAttribute("sql", query.compile().sql);
+          const rows = await builder.execute();
+          return rows.map((x) => transformRichDataTypes(camelCaseObject(x)));
+        });
+      }
+    };
+    __name(_QueryBuilder, "QueryBuilder");
+    var QueryBuilder = _QueryBuilder;
+    module2.exports.QueryBuilder = QueryBuilder;
+  }
+});
+
+// src/ModelAPI.js
+var require_ModelAPI = __commonJS({
+  "src/ModelAPI.js"(exports2, module2) {
+    "use strict";
+    var { sql } = require("kysely");
+    var { useDatabase: useDatabase2 } = require_database();
+    var {
+      transformRichDataTypes,
+      isReferencingExistingRecord
+    } = require_parsing();
+    var { isPlainObject } = require_type_utils();
+    var { QueryBuilder } = require_QueryBuilder();
+    var { QueryContext } = require_QueryContext();
+    var { applyWhereConditions } = require_applyWhereConditions();
+    var { applyJoins } = require_applyJoins();
+    var { InlineFile, File } = require_File();
+    var { Duration } = require_Duration();
+    var {
+      applyLimit,
+      applyOffset,
+      applyOrderBy
+    } = require_applyAdditionalQueryConstraints();
+    var {
+      camelCaseObject,
+      snakeCaseObject,
+      upperCamelCase
+    } = require_casing();
+    var tracing = require_tracing();
+    var { DatabaseError } = require_errors();
+    var _ModelAPI = class _ModelAPI {
+      /**
+       * @param {string} tableName The name of the table this API is for
+       * @param {Function} _ Used to be a function that returns the default values for a row in this table. No longer used.
+       * @param {TableConfigMap} tableConfigMap
+       */
+      constructor(tableName, _, tableConfigMap = {}) {
+        this._tableName = tableName;
+        this._tableConfigMap = tableConfigMap;
+        this._modelName = upperCamelCase(this._tableName);
+      }
+      async create(values) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "create");
+        return tracing.withSpan(name, () => {
+          const db = useDatabase2();
+          return create(
+            db,
+            this._tableName,
+            this._tableConfigMap,
+            snakeCaseObject(values)
+          );
+        });
+      }
+      async findOne(where = {}) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "findOne");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          let builder = db.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
+          const context = new QueryContext([this._tableName], this._tableConfigMap);
+          builder = applyJoins(context, builder, where);
+          builder = applyWhereConditions(context, builder, where);
+          span.setAttribute("sql", builder.compile().sql);
+          const row = await builder.executeTakeFirst();
+          if (!row) {
+            return null;
+          }
+          return transformRichDataTypes(camelCaseObject(row));
+        });
+      }
+      async findMany(params) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "findMany");
+        const db = useDatabase2();
+        const where = (params == null ? void 0 : params.where) || {};
+        return tracing.withSpan(name, async (span) => {
+          const context = new QueryContext([this._tableName], this._tableConfigMap);
+          let builder = db.selectFrom((qb) => {
+            let builder2 = qb.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
+            builder2 = applyJoins(context, builder2, where);
+            builder2 = applyWhereConditions(context, builder2, where);
+            builder2 = builder2.as(this._tableName);
+            return builder2;
+          }).selectAll();
+          if (params == null ? void 0 : params.limit) {
+            builder = applyLimit(context, builder, params.limit);
+          }
+          if (params == null ? void 0 : params.offset) {
+            builder = applyOffset(context, builder, params.offset);
+          }
+          if ((params == null ? void 0 : params.orderBy) !== void 0 && Object.keys(params == null ? void 0 : params.orderBy).length > 0) {
+            builder = applyOrderBy(
+              context,
+              builder,
+              this._tableName,
+              params.orderBy
+            );
+          } else {
+            builder = builder.orderBy(`${this._tableName}.id`);
+          }
+          const query = builder;
+          span.setAttribute("sql", query.compile().sql);
+          const rows = await builder.execute();
+          return rows.map((x) => transformRichDataTypes(camelCaseObject(x)));
+        });
+      }
+      async update(where, values) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "update");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          let builder = db.updateTable(this._tableName).returningAll();
+          const keys = values ? Object.keys(values) : [];
+          const row = {};
+          for (const key of keys) {
+            const value = values[key];
+            if (Array.isArray(value)) {
+              row[key] = await Promise.all(
+                value.map(async (item) => {
+                  if (item instanceof Duration) {
+                    return item.toPostgres();
+                  }
+                  if (item instanceof InlineFile) {
+                    const storedFile = await item.store();
+                    return storedFile.toDbRecord();
+                  }
+                  if (item instanceof File) {
+                    return item.toDbRecord();
+                  }
+                  return item;
+                })
+              );
+            } else if (value instanceof Duration) {
+              row[key] = value.toPostgres();
+            } else if (value instanceof InlineFile) {
+              const storedFile = await value.store();
+              row[key] = storedFile.toDbRecord();
+            } else if (value instanceof File) {
+              row[key] = value.toDbRecord();
+            } else {
+              row[key] = value;
+            }
+          }
+          builder = builder.set(snakeCaseObject(row));
+          const context = new QueryContext([this._tableName], this._tableConfigMap);
+          builder = applyWhereConditions(context, builder, where);
+          span.setAttribute("sql", builder.compile().sql);
+          try {
+            const row2 = await builder.executeTakeFirstOrThrow();
+            return transformRichDataTypes(camelCaseObject(row2));
+          } catch (e) {
+            throw new DatabaseError(e);
+          }
+        });
+      }
+      async delete(where) {
+        const name = tracing.spanNameForModelAPI(this._modelName, "delete");
+        const db = useDatabase2();
+        return tracing.withSpan(name, async (span) => {
+          let builder = db.deleteFrom(this._tableName).returning(["id"]);
+          const context = new QueryContext([this._tableName], this._tableConfigMap);
+          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);
+          }
+        });
+      }
+      where(where) {
+        const db = useDatabase2();
+        let builder = db.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
+        const context = new QueryContext([this._tableName], this._tableConfigMap);
+        builder = applyJoins(context, builder, where);
+        builder = applyWhereConditions(context, builder, where);
+        return new QueryBuilder(this._tableName, context, builder);
+      }
+    };
+    __name(_ModelAPI, "ModelAPI");
+    var ModelAPI = _ModelAPI;
+    async function create(conn, tableName, tableConfigs, values) {
+      try {
+        let query = conn.insertInto(tableName);
+        const keys = values ? Object.keys(values) : [];
+        const tableConfig = tableConfigs[tableName] || {};
+        const hasManyRecords = [];
+        if (keys.length === 0) {
+          query = query.expression(sql`default values`);
+        } else {
+          const row = {};
+          for (const key of keys) {
+            const value = values[key];
+            const columnConfig = tableConfig[key];
+            if (!columnConfig) {
+              if (Array.isArray(value)) {
+                row[key] = await Promise.all(
+                  value.map(async (item) => {
+                    if (item instanceof Duration) {
+                      return item.toPostgres();
+                    }
+                    if (item instanceof InlineFile) {
+                      const storedFile = await item.store();
+                      return storedFile.toDbRecord();
+                    }
+                    if (item instanceof File) {
+                      return item.toDbRecord();
+                    }
+                    return item;
+                  })
+                );
+              } else if (value instanceof Duration) {
+                row[key] = value.toPostgres();
+              } else if (value instanceof InlineFile) {
+                const storedFile = await value.store();
+                row[key] = storedFile.toDbRecord();
+              } else if (value instanceof File) {
+                row[key] = value.toDbRecord();
+              } else {
+                row[key] = value;
+              }
+              continue;
+            }
+            switch (columnConfig.relationshipType) {
+              case "belongsTo":
+                if (!isPlainObject(value)) {
+                  throw new Error(
+                    `non-object provided for field ${key} of ${tableName}`
+                  );
+                }
+                if (isReferencingExistingRecord(value)) {
+                  row[columnConfig.foreignKey] = value.id;
+                  break;
+                }
+                const created2 = await create(
+                  conn,
+                  columnConfig.referencesTable,
+                  tableConfigs,
+                  value
+                );
+                row[columnConfig.foreignKey] = created2.id;
+                break;
+              case "hasMany":
+                if (!Array.isArray(value)) {
+                  throw new Error(
+                    `non-array provided for has-many field ${key} of ${tableName}`
+                  );
+                }
+                for (const v of value) {
+                  hasManyRecords.push({
+                    key,
+                    value: v,
+                    columnConfig
+                  });
+                }
+                break;
+              default:
+                throw new Error(
+                  `unsupported relationship type - ${tableName}.${key} (${columnConfig.relationshipType})`
+                );
+            }
+          }
+          query = query.values(row);
+        }
+        const created = await query.returningAll().executeTakeFirstOrThrow();
+        await Promise.all(
+          hasManyRecords.map(async ({ key, value, columnConfig }) => {
+            if (!isPlainObject(value)) {
+              throw new Error(
+                `non-object provided for field ${key} of ${tableName}`
+              );
+            }
+            if (isReferencingExistingRecord(value)) {
+              throw new Error(
+                `nested update as part of create not supported for ${key} of ${tableConfig}`
+              );
+            }
+            return create(conn, columnConfig.referencesTable, tableConfigs, {
+              ...value,
+              [columnConfig.foreignKey]: created.id
+            });
+          })
+        );
+        return transformRichDataTypes(created);
+      } catch (e) {
+        throw new DatabaseError(e);
+      }
+    }
+    __name(create, "create");
+    module2.exports = {
+      ModelAPI,
+      DatabaseError
+    };
+  }
+});
+
+// src/RequestHeaders.js
+var require_RequestHeaders = __commonJS({
+  "src/RequestHeaders.js"(exports2, module2) {
+    "use strict";
+    var _RequestHeaders = class _RequestHeaders {
+      /**
+       * @param {{Object.<string, string>}} requestHeaders Map of request headers submitted from the client
+       */
+      constructor(requestHeaders) {
+        this._headers = new Headers(requestHeaders);
+      }
+      get(key) {
+        return this._headers.get(key);
+      }
+      has(key) {
+        return this._headers.has(key);
+      }
+    };
+    __name(_RequestHeaders, "RequestHeaders");
+    var RequestHeaders = _RequestHeaders;
+    module2.exports = {
+      RequestHeaders
+    };
+  }
+});
+
+// src/permissions.js
+var require_permissions = __commonJS({
+  "src/permissions.js"(exports2, module2) {
+    "use strict";
+    var { AsyncLocalStorage } = require("async_hooks");
+    var { PermissionError } = require_errors();
+    var PERMISSION_STATE = {
+      UNKNOWN: "unknown",
+      PERMITTED: "permitted",
+      UNPERMITTED: "unpermitted"
+    };
+    var withPermissions = /* @__PURE__ */ __name(async (initialValue, cb) => {
+      const permissions = new Permissions();
+      return await permissionsApiInstance.run({ permitted: initialValue }, () => {
+        return cb({ getPermissionState: permissions.getState });
+      });
+    }, "withPermissions");
+    var permissionsApiInstance = new AsyncLocalStorage();
+    var _Permissions = class _Permissions {
+      // The Go runtime performs role based permission rule checks prior to calling the functions
+      // runtime, so the status could already be granted. If already granted, then we need to inherit that permission state as the state is later used to decide whether to run in process permission checks
+      // TLDR if a role based permission is relevant and it is granted, then it is effectively the same as the end user calling api.permissions.allow() explicitly in terms of behaviour.
+      allow() {
+        const store = permissionsApiInstance.getStore().permitted = true;
+      }
+      deny() {
+        permissionsApiInstance.getStore().permitted = false;
+        throw new PermissionError();
+      }
+      getState() {
+        const permitted = permissionsApiInstance.getStore().permitted;
+        switch (true) {
+          case permitted === false:
+            return PERMISSION_STATE.UNPERMITTED;
+          case permitted === null:
+            return PERMISSION_STATE.UNKNOWN;
+          case permitted === true:
+            return PERMISSION_STATE.PERMITTED;
+        }
+      }
+    };
+    __name(_Permissions, "Permissions");
+    var Permissions = _Permissions;
+    var checkBuiltInPermissions = /* @__PURE__ */ __name(async ({
+      rows,
+      permissionFns,
+      ctx,
+      db,
+      functionName
+    }) => {
+      for (const permissionFn of permissionFns) {
+        const result = await permissionFn(rows, ctx, db);
+        if (result) {
+          return;
+        }
+      }
+      throw new PermissionError(`Not permitted to access ${functionName}`);
+    }, "checkBuiltInPermissions");
+    module2.exports.checkBuiltInPermissions = checkBuiltInPermissions;
+    module2.exports.PermissionError = PermissionError;
+    module2.exports.PERMISSION_STATE = PERMISSION_STATE;
+    module2.exports.Permissions = Permissions;
+    module2.exports.withPermissions = withPermissions;
+    module2.exports.permissionsApiInstance = permissionsApiInstance;
+  }
+});
+
+// src/consts.js
+var require_consts = __commonJS({
+  "src/consts.js"(exports2, module2) {
+    "use strict";
+    var PROTO_ACTION_TYPES = {
+      UNKNOWN: "ACTION_TYPE_UNKNOWN",
+      CREATE: "ACTION_TYPE_CREATE",
+      GET: "ACTION_TYPE_GET",
+      LIST: "ACTION_TYPE_LIST",
+      UPDATE: "ACTION_TYPE_UPDATE",
+      DELETE: "ACTION_TYPE_DELETE",
+      READ: "ACTION_TYPE_READ",
+      WRITE: "ACTION_TYPE_WRITE",
+      JOB: "JOB_TYPE",
+      SUBSCRIBER: "SUBSCRIBER_TYPE",
+      FLOW: "FLOW_TYPE"
+    };
+    module2.exports.PROTO_ACTION_TYPES = PROTO_ACTION_TYPES;
+  }
+});
+
+// src/tryExecuteFunction.js
+var require_tryExecuteFunction = __commonJS({
+  "src/tryExecuteFunction.js"(exports2, module2) {
+    "use strict";
+    var { withDatabase } = require_database();
+    var { withAuditContext } = require_auditing();
+    var {
+      withPermissions,
+      PERMISSION_STATE,
+      checkBuiltInPermissions
+    } = require_permissions();
+    var { PermissionError } = require_errors();
+    var { PROTO_ACTION_TYPES } = require_consts();
+    function tryExecuteFunction({ request, db, permitted, permissionFns, actionType, ctx, functionConfig }, cb) {
+      return withPermissions(permitted, async ({ getPermissionState }) => {
+        let requiresTransaction = true;
+        switch (actionType) {
+          case PROTO_ACTION_TYPES.GET:
+          case PROTO_ACTION_TYPES.LIST:
+          case PROTO_ACTION_TYPES.READ:
+            requiresTransaction = false;
+            break;
+        }
+        if ((functionConfig == null ? void 0 : functionConfig.dbTransaction) !== void 0) {
+          requiresTransaction = functionConfig.dbTransaction;
+        }
+        return withDatabase(db, requiresTransaction, async ({ transaction }) => {
+          const fnResult = await withAuditContext(request, async () => {
+            return cb();
+          });
+          switch (getPermissionState()) {
+            case PERMISSION_STATE.PERMITTED:
+              return fnResult;
+            case PERMISSION_STATE.UNPERMITTED:
+              throw new PermissionError(
+                `Not permitted to access ${request.method}`
+              );
+            default:
+              const relevantPermissions = permissionFns[request.method];
+              const peakInsideTransaction = actionType === PROTO_ACTION_TYPES.CREATE;
+              let rowsForPermissions = [];
+              if (fnResult != null) {
+                switch (actionType) {
+                  case PROTO_ACTION_TYPES.LIST:
+                    rowsForPermissions = fnResult;
+                    break;
+                  case PROTO_ACTION_TYPES.DELETE:
+                    rowsForPermissions = [{ id: fnResult }];
+                    break;
+                  case (PROTO_ACTION_TYPES.GET, PROTO_ACTION_TYPES.CREATE):
+                    rowsForPermissions = [fnResult];
+                    break;
+                  default:
+                    rowsForPermissions = [fnResult];
+                    break;
+                }
+              }
+              await checkBuiltInPermissions({
+                rows: rowsForPermissions,
+                permissionFns: relevantPermissions,
+                // it is important that we pass db here as db represents the connection to the database
+                // *outside* of the current transaction. Given that any changes inside of a transaction
+                // are opaque to the outside, we can utilize this when running permission rules and then deciding to
+                // rollback any changes if they do not pass. However, for creates we need to be able to 'peak' inside the transaction to read the created record, as this won't exist outside of the transaction.
+                db: peakInsideTransaction ? transaction : db,
+                ctx,
+                functionName: request.method
+              });
+              return fnResult;
+          }
+        });
+      });
+    }
+    __name(tryExecuteFunction, "tryExecuteFunction");
+    module2.exports.tryExecuteFunction = tryExecuteFunction;
+  }
+});
+
+// src/handleRequest.js
+var require_handleRequest = __commonJS({
+  "src/handleRequest.js"(exports2, module2) {
+    "use strict";
+    var {
+      createJSONRPCErrorResponse,
+      createJSONRPCSuccessResponse,
+      JSONRPCErrorCode
+    } = require("json-rpc-2.0");
+    var { createDatabaseClient } = require_database();
+    var { tryExecuteFunction } = require_tryExecuteFunction();
+    var { errorToJSONRPCResponse, RuntimeErrors } = require_errors();
+    var opentelemetry = require("@opentelemetry/api");
+    var { withSpan } = require_tracing();
+    var { parseInputs, parseOutputs } = require_parsing();
+    async function handleRequest(request, config) {
+      var _a;
+      const activeContext = opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        (_a = request.meta) == null ? void 0 : _a.tracing
+      );
+      if (process.env.KEEL_LOG_LEVEL == "debug") {
+        console.log(request);
+      }
+      return opentelemetry.context.with(activeContext, () => {
+        return withSpan(request.method, async (span) => {
+          var _a2, _b;
+          let db = null;
+          try {
+            const { createContextAPI, functions, permissionFns, actionTypes } = config;
+            if (!(request.method in functions)) {
+              const message = `no corresponding function found for '${request.method}'`;
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message
+              });
+              return createJSONRPCErrorResponse(
+                request.id,
+                JSONRPCErrorCode.MethodNotFound,
+                message
+              );
+            }
+            const headers = new Headers();
+            const ctx = createContextAPI({
+              responseHeaders: headers,
+              meta: request.meta
+            });
+            const permitted = request.meta && request.meta.permissionState.status === "granted" ? true : null;
+            db = createDatabaseClient({
+              connString: (_b = (_a2 = request.meta) == null ? void 0 : _a2.secrets) == null ? void 0 : _b.KEEL_DB_CONN
+            });
+            const customFunction = functions[request.method];
+            const actionType = actionTypes[request.method];
+            const functionConfig = (customFunction == null ? void 0 : customFunction.config) ?? {};
+            const result = await tryExecuteFunction(
+              {
+                request,
+                ctx,
+                permitted,
+                db,
+                permissionFns,
+                actionType,
+                functionConfig
+              },
+              async () => {
+                const inputs = parseInputs(request.params);
+                const result2 = await customFunction(ctx, inputs);
+                return parseOutputs(result2);
+              }
+            );
+            if (result instanceof Error) {
+              span.recordException(result);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: result.message
+              });
+              return errorToJSONRPCResponse(request, result);
+            }
+            const response = createJSONRPCSuccessResponse(request.id, result);
+            const responseHeaders = {};
+            for (const pair of headers.entries()) {
+              responseHeaders[pair[0]] = pair[1].split(", ");
+            }
+            response.meta = {
+              headers: responseHeaders,
+              status: ctx.response.status
+            };
+            return response;
+          } catch (e) {
+            if (e instanceof Error) {
+              span.recordException(e);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: e.message
+              });
+              return errorToJSONRPCResponse(request, e);
+            }
+            const message = JSON.stringify(e);
+            span.setStatus({
+              code: opentelemetry.SpanStatusCode.ERROR,
+              message
+            });
+            return createJSONRPCErrorResponse(
+              request.id,
+              RuntimeErrors.UnknownError,
+              message
+            );
+          } finally {
+            if (db) {
+              await db.destroy();
+            }
+          }
+        });
+      });
+    }
+    __name(handleRequest, "handleRequest");
+    module2.exports = {
+      handleRequest,
+      RuntimeErrors
+    };
+  }
+});
+
+// src/tryExecuteJob.js
+var require_tryExecuteJob = __commonJS({
+  "src/tryExecuteJob.js"(exports2, module2) {
+    "use strict";
+    var { withDatabase } = require_database();
+    var { withAuditContext } = require_auditing();
+    var { withPermissions, PERMISSION_STATE } = require_permissions();
+    var { PermissionError } = require_errors();
+    function tryExecuteJob({ db, permitted, request, functionConfig }, cb) {
+      return withPermissions(permitted, async ({ getPermissionState }) => {
+        let requiresTransaction = false;
+        if ((functionConfig == null ? void 0 : functionConfig.dbTransaction) !== void 0) {
+          requiresTransaction = functionConfig.dbTransaction;
+        }
+        return withDatabase(db, requiresTransaction, async () => {
+          await withAuditContext(request, async () => {
+            return cb();
+          });
+          if (getPermissionState() === PERMISSION_STATE.UNPERMITTED) {
+            throw new PermissionError(`Not permitted to access ${request.method}`);
+          }
+        });
+      });
+    }
+    __name(tryExecuteJob, "tryExecuteJob");
+    module2.exports.tryExecuteJob = tryExecuteJob;
+  }
+});
+
+// src/handleJob.js
+var require_handleJob = __commonJS({
+  "src/handleJob.js"(exports2, module2) {
+    "use strict";
+    var {
+      createJSONRPCErrorResponse,
+      createJSONRPCSuccessResponse,
+      JSONRPCErrorCode
+    } = require("json-rpc-2.0");
+    var { createDatabaseClient } = require_database();
+    var { errorToJSONRPCResponse, RuntimeErrors } = require_errors();
+    var opentelemetry = require("@opentelemetry/api");
+    var { withSpan } = require_tracing();
+    var { tryExecuteJob } = require_tryExecuteJob();
+    var { parseInputs } = require_parsing();
+    var { PROTO_ACTION_TYPES } = require_consts();
+    async function handleJob(request, config) {
+      var _a;
+      const activeContext = opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        (_a = request.meta) == null ? void 0 : _a.tracing
+      );
+      return opentelemetry.context.with(activeContext, () => {
+        return withSpan(request.method, async (span) => {
+          var _a2, _b;
+          let db = null;
+          try {
+            const { createJobContextAPI, jobs } = config;
+            if (!(request.method in jobs)) {
+              const message = `no corresponding job found for '${request.method}'`;
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message
+              });
+              return createJSONRPCErrorResponse(
+                request.id,
+                JSONRPCErrorCode.MethodNotFound,
+                message
+              );
+            }
+            const ctx = createJobContextAPI({
+              meta: request.meta
+            });
+            const permitted = request.meta && request.meta.permissionState.status === "granted" ? true : null;
+            db = createDatabaseClient({
+              connString: (_b = (_a2 = request.meta) == null ? void 0 : _a2.secrets) == null ? void 0 : _b.KEEL_DB_CONN
+            });
+            const jobFunction = jobs[request.method];
+            const actionType = PROTO_ACTION_TYPES.JOB;
+            const functionConfig = (jobFunction == null ? void 0 : jobFunction.config) ?? {};
+            await tryExecuteJob(
+              { request, permitted, db, actionType, functionConfig },
+              async () => {
+                const inputs = parseInputs(request.params);
+                return jobFunction(ctx, inputs);
+              }
+            );
+            return createJSONRPCSuccessResponse(request.id, null);
+          } catch (e) {
+            if (e instanceof Error) {
+              span.recordException(e);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: e.message
+              });
+              return errorToJSONRPCResponse(request, e);
+            }
+            const message = JSON.stringify(e);
+            span.setStatus({
+              code: opentelemetry.SpanStatusCode.ERROR,
+              message
+            });
+            return createJSONRPCErrorResponse(
+              request.id,
+              RuntimeErrors.UnknownError,
+              message
+            );
+          } finally {
+            if (db) {
+              await db.destroy();
+            }
+          }
+        });
+      });
+    }
+    __name(handleJob, "handleJob");
+    module2.exports = {
+      handleJob,
+      RuntimeErrors
+    };
+  }
+});
+
+// src/tryExecuteSubscriber.js
+var require_tryExecuteSubscriber = __commonJS({
+  "src/tryExecuteSubscriber.js"(exports2, module2) {
+    "use strict";
+    var { withDatabase } = require_database();
+    var { withAuditContext } = require_auditing();
+    function tryExecuteSubscriber({ request, db, functionConfig }, cb) {
+      let requiresTransaction = false;
+      if ((functionConfig == null ? void 0 : functionConfig.dbTransaction) !== void 0) {
+        requiresTransaction = functionConfig.dbTransaction;
+      }
+      return withDatabase(db, requiresTransaction, async () => {
+        await withAuditContext(request, async () => {
+          return cb();
+        });
+      });
+    }
+    __name(tryExecuteSubscriber, "tryExecuteSubscriber");
+    module2.exports.tryExecuteSubscriber = tryExecuteSubscriber;
+  }
+});
+
+// src/handleSubscriber.js
+var require_handleSubscriber = __commonJS({
+  "src/handleSubscriber.js"(exports2, module2) {
+    "use strict";
+    var {
+      createJSONRPCErrorResponse,
+      createJSONRPCSuccessResponse,
+      JSONRPCErrorCode
+    } = require("json-rpc-2.0");
+    var { createDatabaseClient } = require_database();
+    var { errorToJSONRPCResponse, RuntimeErrors } = require_errors();
+    var opentelemetry = require("@opentelemetry/api");
+    var { withSpan } = require_tracing();
+    var { PROTO_ACTION_TYPES } = require_consts();
+    var { tryExecuteSubscriber } = require_tryExecuteSubscriber();
+    var { parseInputs } = require_parsing();
+    async function handleSubscriber(request, config) {
+      var _a;
+      const activeContext = opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        (_a = request.meta) == null ? void 0 : _a.tracing
+      );
+      return opentelemetry.context.with(activeContext, () => {
+        return withSpan(request.method, async (span) => {
+          var _a2, _b;
+          let db = null;
+          try {
+            const { createSubscriberContextAPI, subscribers } = config;
+            if (!(request.method in subscribers)) {
+              const message = `no corresponding subscriber found for '${request.method}'`;
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message
+              });
+              return createJSONRPCErrorResponse(
+                request.id,
+                JSONRPCErrorCode.MethodNotFound,
+                message
+              );
+            }
+            const ctx = createSubscriberContextAPI({
+              meta: request.meta
+            });
+            db = createDatabaseClient({
+              connString: (_b = (_a2 = request.meta) == null ? void 0 : _a2.secrets) == null ? void 0 : _b.KEEL_DB_CONN
+            });
+            const subscriberFunction = subscribers[request.method];
+            const actionType = PROTO_ACTION_TYPES.SUBSCRIBER;
+            const functionConfig = (subscriberFunction == null ? void 0 : subscriberFunction.config) ?? {};
+            await tryExecuteSubscriber(
+              { request, db, actionType, functionConfig },
+              async () => {
+                const inputs = parseInputs(request.params);
+                return subscriberFunction(ctx, inputs);
+              }
+            );
+            return createJSONRPCSuccessResponse(request.id, null);
+          } catch (e) {
+            if (e instanceof Error) {
+              span.recordException(e);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: e.message
+              });
+              return errorToJSONRPCResponse(request, e);
+            }
+            const message = JSON.stringify(e);
+            span.setStatus({
+              code: opentelemetry.SpanStatusCode.ERROR,
+              message
+            });
+            return createJSONRPCErrorResponse(
+              request.id,
+              RuntimeErrors.UnknownError,
+              message
+            );
+          } finally {
+            if (db) {
+              await db.destroy();
+            }
+          }
+        });
+      });
+    }
+    __name(handleSubscriber, "handleSubscriber");
+    module2.exports = {
+      handleSubscriber,
+      RuntimeErrors
+    };
+  }
+});
+
+// src/handleRoute.js
+var require_handleRoute = __commonJS({
+  "src/handleRoute.js"(exports2, module2) {
+    "use strict";
+    var {
+      createJSONRPCErrorResponse,
+      createJSONRPCSuccessResponse,
+      JSONRPCErrorCode
+    } = require("json-rpc-2.0");
+    var { createDatabaseClient, withDatabase } = require_database();
+    var { withAuditContext } = require_auditing();
+    var { errorToJSONRPCResponse, RuntimeErrors } = require_errors();
+    var opentelemetry = require("@opentelemetry/api");
+    var { withSpan } = require_tracing();
+    async function handleRoute(request, config) {
+      var _a;
+      const activeContext = opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        (_a = request.meta) == null ? void 0 : _a.tracing
+      );
+      return opentelemetry.context.with(activeContext, () => {
+        return withSpan(request.method, async (span) => {
+          var _a2, _b;
+          let db = null;
+          try {
+            const { createContextAPI, functions } = config;
+            if (!(request.method in functions)) {
+              const message = `no route function found for '${request.method}'`;
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message
+              });
+              return createJSONRPCErrorResponse(
+                request.id,
+                JSONRPCErrorCode.MethodNotFound,
+                message
+              );
+            }
+            const {
+              headers,
+              response: __,
+              ...ctx
+            } = createContextAPI({
+              responseHeaders: new Headers(),
+              meta: request.meta
+            });
+            request.params.headers = headers;
+            db = createDatabaseClient({
+              connString: (_b = (_a2 = request.meta) == null ? void 0 : _a2.secrets) == null ? void 0 : _b.KEEL_DB_CONN
+            });
+            const routeHandler = functions[request.method];
+            const result = await withDatabase(db, false, () => {
+              return withAuditContext(request, () => {
+                return routeHandler(request.params, ctx);
+              });
+            });
+            if (result instanceof Error) {
+              span.recordException(result);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: result.message
+              });
+              return errorToJSONRPCResponse(request, result);
+            }
+            const response = createJSONRPCSuccessResponse(request.id, result);
+            return response;
+          } catch (e) {
+            if (e instanceof Error) {
+              span.recordException(e);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: e.message
+              });
+              return errorToJSONRPCResponse(request, e);
+            }
+            const message = JSON.stringify(e);
+            span.setStatus({
+              code: opentelemetry.SpanStatusCode.ERROR,
+              message
+            });
+            return createJSONRPCErrorResponse(
+              request.id,
+              RuntimeErrors.UnknownError,
+              message
+            );
+          } finally {
+            if (db) {
+              await db.destroy();
+            }
+          }
+        });
+      });
+    }
+    __name(handleRoute, "handleRoute");
+    module2.exports = {
+      handleRoute,
+      RuntimeErrors
+    };
+  }
+});
+
+// src/tryExecuteFlow.js
+var require_tryExecuteFlow = __commonJS({
+  "src/tryExecuteFlow.js"(exports2, module2) {
+    "use strict";
+    var { withDatabase } = require_database();
+    function tryExecuteFlow(db, cb) {
+      return withDatabase(db, false, async () => {
+        return cb();
+      });
+    }
+    __name(tryExecuteFlow, "tryExecuteFlow");
+    module2.exports.tryExecuteFlow = tryExecuteFlow;
+  }
+});
+
+// src/flows/ui/elements/input/text.ts
+var textInput;
+var init_text = __esm({
+  "src/flows/ui/elements/input/text.ts"() {
+    "use strict";
+    textInput = /* @__PURE__ */ __name((name, options) => {
+      return {
+        uiConfig: {
+          __type: "ui.input.text",
+          name,
+          label: (options == null ? void 0 : options.label) || name,
+          defaultValue: options == null ? void 0 : options.defaultValue,
+          optional: options == null ? void 0 : options.optional,
+          placeholder: options == null ? void 0 : options.placeholder,
+          multiline: options == null ? void 0 : options.multiline,
+          maxLength: options == null ? void 0 : options.maxLength,
+          minLength: options == null ? void 0 : options.minLength
+        },
+        validate: options == null ? void 0 : options.validate,
+        getData: /* @__PURE__ */ __name((x) => x, "getData")
+      };
+    }, "textInput");
+  }
+});
+
+// src/flows/ui/elements/input/number.ts
+var numberInput;
+var init_number = __esm({
+  "src/flows/ui/elements/input/number.ts"() {
+    "use strict";
+    numberInput = /* @__PURE__ */ __name((name, options) => {
+      return {
+        uiConfig: {
+          __type: "ui.input.number",
+          name,
+          label: (options == null ? void 0 : options.label) || name,
+          defaultValue: options == null ? void 0 : options.defaultValue,
+          optional: options == null ? void 0 : options.optional,
+          placeholder: options == null ? void 0 : options.placeholder,
+          min: options == null ? void 0 : options.min,
+          max: options == null ? void 0 : options.max
+        },
+        validate: options == null ? void 0 : options.validate,
+        getData: /* @__PURE__ */ __name((x) => x, "getData")
+      };
+    }, "numberInput");
+  }
+});
+
+// src/flows/ui/elements/display/divider.ts
+var divider;
+var init_divider = __esm({
+  "src/flows/ui/elements/display/divider.ts"() {
+    "use strict";
+    divider = /* @__PURE__ */ __name((options) => {
+      return {
+        uiConfig: {
+          __type: "ui.display.divider"
+        }
+      };
+    }, "divider");
+  }
+});
+
+// src/flows/ui/elements/input/boolean.ts
+var booleanInput;
+var init_boolean = __esm({
+  "src/flows/ui/elements/input/boolean.ts"() {
+    "use strict";
+    booleanInput = /* @__PURE__ */ __name((name, options) => {
+      return {
+        uiConfig: {
+          __type: "ui.input.boolean",
+          name,
+          label: (options == null ? void 0 : options.label) || name,
+          defaultValue: options == null ? void 0 : options.defaultValue,
+          optional: options == null ? void 0 : options.optional,
+          mode: (options == null ? void 0 : options.mode) || "checkbox"
+        },
+        validate: options == null ? void 0 : options.validate,
+        getData: /* @__PURE__ */ __name((x) => x, "getData")
+      };
+    }, "booleanInput");
+  }
+});
+
+// src/flows/ui/elements/display/markdown.ts
+var markdown;
+var init_markdown = __esm({
+  "src/flows/ui/elements/display/markdown.ts"() {
+    "use strict";
+    markdown = /* @__PURE__ */ __name((options) => {
+      return {
+        uiConfig: {
+          __type: "ui.display.markdown",
+          content: (options == null ? void 0 : options.content) || ""
+        }
+      };
+    }, "markdown");
+  }
+});
+
+// src/flows/ui/elements/display/table.ts
+var table;
+var init_table = __esm({
+  "src/flows/ui/elements/display/table.ts"() {
+    "use strict";
+    table = /* @__PURE__ */ __name((options) => {
+      return {
+        uiConfig: {
+          __type: "ui.display.table",
+          data: (options == null ? void 0 : options.data) || [],
+          columns: (options == null ? void 0 : options.columns) || []
+        }
+      };
+    }, "table");
+  }
+});
+
+// src/flows/ui/elements/select/single.ts
+var selectOne;
+var init_single = __esm({
+  "src/flows/ui/elements/select/single.ts"() {
+    "use strict";
+    selectOne = /* @__PURE__ */ __name((name, options) => {
+      return {
+        uiConfig: {
+          __type: "ui.select.single",
+          name,
+          label: (options == null ? void 0 : options.label) || name,
+          defaultValue: options == null ? void 0 : options.defaultValue,
+          optional: options == null ? void 0 : options.optional,
+          options: []
+        },
+        validate: options == null ? void 0 : options.validate,
+        getData: /* @__PURE__ */ __name((x) => x, "getData")
+      };
+    }, "selectOne");
+  }
+});
+
+// src/flows/disrupts.ts
+var disrupts_exports = {};
+__export(disrupts_exports, {
+  StepCompletedDisrupt: () => StepCompletedDisrupt,
+  StepErrorDisrupt: () => StepErrorDisrupt,
+  UIRenderDisrupt: () => UIRenderDisrupt
+});
+var _FlowDisrupt, FlowDisrupt, _UIRenderDisrupt, UIRenderDisrupt, _StepErrorDisrupt, StepErrorDisrupt, _StepCompletedDisrupt, StepCompletedDisrupt;
+var init_disrupts = __esm({
+  "src/flows/disrupts.ts"() {
+    "use strict";
+    _FlowDisrupt = class _FlowDisrupt {
+      constructor() {
+      }
+    };
+    __name(_FlowDisrupt, "FlowDisrupt");
+    FlowDisrupt = _FlowDisrupt;
+    _UIRenderDisrupt = class _UIRenderDisrupt extends FlowDisrupt {
+      constructor(stepId, contents) {
+        super();
+        this.stepId = stepId;
+        this.contents = contents;
+      }
+    };
+    __name(_UIRenderDisrupt, "UIRenderDisrupt");
+    UIRenderDisrupt = _UIRenderDisrupt;
+    _StepErrorDisrupt = class _StepErrorDisrupt extends FlowDisrupt {
+      constructor(errorMessage) {
+        super();
+        this.errorMessage = errorMessage;
+      }
+    };
+    __name(_StepErrorDisrupt, "StepErrorDisrupt");
+    StepErrorDisrupt = _StepErrorDisrupt;
+    _StepCompletedDisrupt = class _StepCompletedDisrupt extends FlowDisrupt {
+      constructor() {
+        super();
+      }
+    };
+    __name(_StepCompletedDisrupt, "StepCompletedDisrupt");
+    StepCompletedDisrupt = _StepCompletedDisrupt;
+  }
+});
+
+// src/flows/index.ts
+var flows_exports = {};
+__export(flows_exports, {
+  createStepContext: () => createStepContext
+});
+function createStepContext(runId, data, spanId) {
+  return {
+    step: /* @__PURE__ */ __name(async (name, fn, opts) => {
+      const db = (0, import_database.useDatabase)();
+      const completed = await db.selectFrom("keel_flow_step").where("run_id", "=", runId).where("name", "=", name).where("status", "=", "COMPLETED" /* COMPLETED */).selectAll().executeTakeFirst();
+      if (completed) {
+        return completed.value;
+      }
+      const step = await db.insertInto("keel_flow_step").values({
+        run_id: runId,
+        name,
+        status: "NEW" /* NEW */,
+        type: "FUNCTION" /* FUNCTION */,
+        maxRetries: (opts == null ? void 0 : opts.maxRetries) ?? defaultOpts.maxRetries,
+        timeoutInMs: (opts == null ? void 0 : opts.timeoutInMs) ?? defaultOpts.timeoutInMs
+      }).returningAll().executeTakeFirst();
+      let result = null;
+      try {
+        result = await withTimeout(fn(), step.timeoutInMs);
+      } catch (e) {
+        await db.updateTable("keel_flow_step").set({
+          status: "FAILED" /* FAILED */,
+          spanId
+          // TODO: store error message
+        }).where("id", "=", step.id).returningAll().executeTakeFirst();
+        throw new StepErrorDisrupt(
+          e instanceof Error ? e.message : "an error occurred"
+        );
+      }
+      await db.updateTable("keel_flow_step").set({
+        status: "COMPLETED" /* COMPLETED */,
+        value: JSON.stringify(result),
+        spanId
+      }).where("id", "=", step.id).returningAll().executeTakeFirst();
+      throw new StepCompletedDisrupt();
+    }, "step"),
+    ui: {
+      page: /* @__PURE__ */ __name(async (page) => {
+        const db = (0, import_database.useDatabase)();
+        let step = await db.selectFrom("keel_flow_step").where("run_id", "=", runId).where("name", "=", page.title).selectAll().executeTakeFirst();
+        if (step && step.status === "COMPLETED" /* COMPLETED */) {
+          return step.value;
+        }
+        if (!step) {
+          step = await db.insertInto("keel_flow_step").values({
+            run_id: runId,
+            name: page.title,
+            status: "PENDING" /* PENDING */,
+            type: "UI" /* UI */,
+            maxRetries: 3,
+            timeoutInMs: 1e3
+          }).returningAll().executeTakeFirst();
+        }
+        if (data) {
+          await db.updateTable("keel_flow_step").set({
+            status: "COMPLETED" /* COMPLETED */,
+            value: JSON.stringify(data),
+            spanId
+          }).where("id", "=", step.id).returningAll().executeTakeFirst();
+          return data;
+        } else {
+          throw new UIRenderDisrupt(step.id, page);
+        }
+      }, "page"),
+      inputs: {
+        text: textInput,
+        number: numberInput,
+        boolean: booleanInput
+      },
+      display: {
+        divider,
+        markdown,
+        table
+      },
+      select: {
+        single: selectOne
+      }
+    }
+  };
+}
+function wait(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function withTimeout(promiseFn, timeout) {
+  return Promise.race([
+    promiseFn,
+    wait(timeout).then(() => {
+      throw new Error(`flow times out after ${timeout}ms`);
+    })
+  ]);
+}
+var import_database, defaultOpts;
+var init_flows = __esm({
+  "src/flows/index.ts"() {
+    "use strict";
+    import_database = __toESM(require_database());
+    init_text();
+    init_number();
+    init_divider();
+    init_boolean();
+    init_markdown();
+    init_table();
+    init_single();
+    init_disrupts();
+    defaultOpts = {
+      maxRetries: 5,
+      timeoutInMs: 6e4
+    };
+    __name(createStepContext, "createStepContext");
+    __name(wait, "wait");
+    __name(withTimeout, "withTimeout");
+  }
+});
+
+// src/handleFlow.js
+var require_handleFlow = __commonJS({
+  "src/handleFlow.js"(exports2, module2) {
+    "use strict";
+    var {
+      createJSONRPCErrorResponse,
+      createJSONRPCSuccessResponse,
+      JSONRPCErrorCode
+    } = require("json-rpc-2.0");
+    var { createDatabaseClient } = require_database();
+    var { errorToJSONRPCResponse, RuntimeErrors } = require_errors();
+    var opentelemetry = require("@opentelemetry/api");
+    var { withSpan } = require_tracing();
+    var { tryExecuteFlow } = require_tryExecuteFlow();
+    var { parseInputs } = require_parsing();
+    var { createStepContext: createStepContext2 } = (init_flows(), __toCommonJS(flows_exports));
+    var {
+      StepCompletedDisrupt: StepCompletedDisrupt2,
+      StepErrorDisrupt: StepErrorDisrupt2,
+      UIRenderDisrupt: UIRenderDisrupt2
+    } = (init_disrupts(), __toCommonJS(disrupts_exports));
+    async function handleFlow(request, config) {
+      var _a;
+      const activeContext = opentelemetry.propagation.extract(
+        opentelemetry.context.active(),
+        (_a = request.meta) == null ? void 0 : _a.tracing
+      );
+      return opentelemetry.context.with(activeContext, () => {
+        return withSpan(request.method, async (span) => {
+          var _a2, _b, _c;
+          let db = null;
+          let flowConfig = null;
+          const runId = (_a2 = request.meta) == null ? void 0 : _a2.runId;
+          try {
+            if (!runId) {
+              throw new Error("no runId provided");
+            }
+            const { flows } = config;
+            if (!(request.method in flows)) {
+              const message = `no corresponding flow found for '${request.method}'`;
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message
+              });
+              return createJSONRPCErrorResponse(
+                request.id,
+                JSONRPCErrorCode.MethodNotFound,
+                message
+              );
+            }
+            db = createDatabaseClient({
+              connString: (_c = (_b = request.meta) == null ? void 0 : _b.secrets) == null ? void 0 : _c.KEEL_DB_CONN
+            });
+            const flowRun = await db.selectFrom("keel_flow_run").where("id", "=", runId).selectAll().executeTakeFirst();
+            if (!flowRun) {
+              throw new Error("no flow run found");
+            }
+            const ctx = createStepContext2(
+              request.meta.runId,
+              request.meta.data,
+              span.spanContext().spanId
+            );
+            const flowFunction = flows[request.method].fn;
+            flowConfig = flows[request.method].config;
+            await tryExecuteFlow(db, async () => {
+              const inputs = parseInputs(flowRun.input);
+              return flowFunction(ctx, inputs);
+            });
+            return createJSONRPCSuccessResponse(request.id, {
+              runId,
+              runCompleted: true,
+              config: flowConfig
+            });
+          } catch (e) {
+            if (e instanceof StepCompletedDisrupt2) {
+              return createJSONRPCSuccessResponse(request.id, {
+                runId,
+                runCompleted: false,
+                config: flowConfig
+              });
+            }
+            if (e instanceof UIRenderDisrupt2) {
+              return createJSONRPCSuccessResponse(request.id, {
+                runId,
+                stepId: e.stepId,
+                config: flowConfig,
+                ui: e.contents
+              });
+            }
+            if (e instanceof Error) {
+              span.recordException(e);
+              span.setStatus({
+                code: opentelemetry.SpanStatusCode.ERROR,
+                message: e.message
+              });
+              return errorToJSONRPCResponse(request, e);
+            }
+            const message = JSON.stringify(e);
+            span.setStatus({
+              code: opentelemetry.SpanStatusCode.ERROR,
+              message
+            });
+            return createJSONRPCErrorResponse(
+              request.id,
+              RuntimeErrors.UnknownError,
+              message
+            );
+          } finally {
+            if (db) {
+              await db.destroy();
+            }
+          }
+        });
+      });
+    }
+    __name(handleFlow, "handleFlow");
+    module2.exports = {
+      handleFlow,
+      RuntimeErrors
+    };
+  }
+});
+
+// src/index.js
+var require_index = __commonJS({
+  "src/index.js"(exports2, module2) {
+    "use strict";
+    var { ModelAPI } = require_ModelAPI();
+    var { RequestHeaders } = require_RequestHeaders();
+    var { handleRequest } = require_handleRequest();
+    var { handleJob } = require_handleJob();
+    var { handleSubscriber } = require_handleSubscriber();
+    var { handleRoute } = require_handleRoute();
+    var { handleFlow } = require_handleFlow();
+    var KSUID = require("ksuid");
+    var { useDatabase: useDatabase2 } = require_database();
+    var {
+      Permissions,
+      PERMISSION_STATE,
+      checkBuiltInPermissions
+    } = require_permissions();
+    var tracing = require_tracing();
+    var { InlineFile, File } = require_File();
+    var { Duration } = require_Duration();
+    var { ErrorPresets } = require_errors();
+    module2.exports = {
+      ModelAPI,
+      RequestHeaders,
+      handleRequest,
+      handleJob,
+      handleSubscriber,
+      handleRoute,
+      handleFlow,
+      KSUID,
+      useDatabase: useDatabase2,
+      Permissions,
+      PERMISSION_STATE,
+      checkBuiltInPermissions,
+      tracing,
+      InlineFile,
+      File,
+      Duration,
+      ErrorPresets,
+      ksuid() {
+        return KSUID.randomSync().string;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+module.exports = __toCommonJS(index_exports);
+__reExport(index_exports, __toESM(require_index()), module.exports);
+init_flows();
+//# sourceMappingURL=index.js.map