@teamkeel/functions-runtime 0.412.1 → 0.413.2-next.1

package/dist/index.cjs

@@ -0,0 +1,2842 @@
+"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 __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 __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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Duration: () => Duration,
+  ErrorPresets: () => ErrorPresets,
+  File: () => File,
+  InlineFile: () => InlineFile,
+  KSUID: () => import_ksuid2.default,
+  ModelAPI: () => ModelAPI,
+  PERMISSION_STATE: () => PERMISSION_STATE,
+  Permissions: () => Permissions,
+  RequestHeaders: () => RequestHeaders,
+  checkBuiltInPermissions: () => checkBuiltInPermissions,
+  createFlowContext: () => createFlowContext,
+  handleFlow: () => handleFlow,
+  handleJob: () => handleJob,
+  handleRequest: () => handleRequest,
+  handleRoute: () => handleRoute,
+  handleSubscriber: () => handleSubscriber,
+  ksuid: () => ksuid,
+  tracing: () => tracing_exports,
+  useDatabase: () => useDatabase
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/ModelAPI.js
+var import_kysely5 = require("kysely");
+
+// src/database.ts
+var import_kysely3 = require("kysely");
+var neon = __toESM(require("@neondatabase/serverless"), 1);
+var import_node_async_hooks2 = require("async_hooks");
+
+// src/auditing.js
+var import_node_async_hooks = require("async_hooks");
+var import_traceparent = __toESM(require("traceparent"), 1);
+var import_kysely = require("kysely");
+var auditContextStorage = new import_node_async_hooks.AsyncLocalStorage();
+async function withAuditContext(request, cb) {
+  let audit = {};
+  if (request.meta?.identity) {
+    audit.identityId = request.meta.identity.id;
+  }
+  if (request.meta?.tracing?.traceparent) {
+    audit.traceId = import_traceparent.default.fromString(
+      request.meta.tracing.traceparent
+    )?.traceId;
+  }
+  return await auditContextStorage.run(audit, () => {
+    return cb();
+  });
+}
+__name(withAuditContext, "withAuditContext");
+function getAuditContext() {
+  let auditStore = auditContextStorage.getStore();
+  return {
+    identityId: auditStore?.identityId,
+    traceId: auditStore?.traceId
+  };
+}
+__name(getAuditContext, "getAuditContext");
+var AuditContextPlugin = class {
+  static {
+    __name(this, "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 = import_kysely.sql`set_identity_id(${audit.identityId})`.as(this.identityIdAlias).toOperationNode();
+          returning.selections.push(import_kysely.SelectionNode.create(rawNode));
+        }
+        if (audit.traceId) {
+          const rawNode = import_kysely.sql`set_trace_id(${audit.traceId})`.as(this.traceIdAlias).toOperationNode();
+          returning.selections.push(import_kysely.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) {
+    if (args.result?.rows) {
+      for (let i = 0; i < args.result.rows.length; i++) {
+        delete args.result.rows[i][this.identityIdAlias];
+        delete args.result.rows[i][this.traceIdAlias];
+      }
+    }
+    return args.result;
+  }
+};
+
+// src/camelCasePlugin.js
+var import_kysely2 = require("kysely");
+
+// src/Duration.ts
+var import_postgres_interval = __toESM(require("postgres-interval"), 1);
+var isoRegex = /^P(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)D)?(?:T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?)?$/;
+var Duration = class _Duration {
+  static {
+    __name(this, "Duration");
+  }
+  constructor(postgresString) {
+    this._typename = "Duration";
+    this.pgInterval = postgresString;
+    this._interval = (0, import_postgres_interval.default)(postgresString);
+  }
+  static fromISOString(isoString) {
+    const match = isoString.match(isoRegex);
+    if (match) {
+      const d = new _Duration("0");
+      d._interval.years = match[1] ? parseInt(match[1]) : void 0;
+      d._interval.months = match[2] ? parseInt(match[2]) : void 0;
+      d._interval.days = match[3] ? parseInt(match[3]) : void 0;
+      d._interval.hours = match[4] ? parseInt(match[4]) : void 0;
+      d._interval.minutes = match[5] ? parseInt(match[5]) : void 0;
+      d._interval.seconds = match[6] ? parseInt(match[6]) : void 0;
+      return d;
+    }
+    return new _Duration("0");
+  }
+  toISOString() {
+    return this._interval.toISOStringShort();
+  }
+  toPostgres() {
+    return this._interval.toPostgres();
+  }
+};
+
+// src/type-utils.ts
+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");
+
+// src/camelCasePlugin.js
+var KeelCamelCasePlugin = class {
+  static {
+    __name(this, "KeelCamelCasePlugin");
+  }
+  constructor(opt) {
+    this.opt = opt;
+    this.CamelCasePlugin = new import_kysely2.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;
+    }, {});
+  }
+};
+function canMap(obj, opt) {
+  return isPlainObject(obj) && !opt?.maintainNestedObjectKeys && !isRichType(obj);
+}
+__name(canMap, "canMap");
+
+// src/database.ts
+var import_pg = require("pg");
+
+// src/tracing.js
+var tracing_exports = {};
+__export(tracing_exports, {
+  forceFlush: () => forceFlush,
+  getTracer: () => getTracer,
+  init: () => init,
+  spanNameForModelAPI: () => spanNameForModelAPI,
+  withSpan: () => withSpan
+});
+var opentelemetry = __toESM(require("@opentelemetry/api"), 1);
+var import_sdk_trace_base = require("@opentelemetry/sdk-trace-base");
+var import_exporter_trace_otlp_proto = require("@opentelemetry/exporter-trace-otlp-proto");
+var import_sdk_trace_node = require("@opentelemetry/sdk-trace-node");
+var import_resources = 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 import_exporter_trace_otlp_proto.OTLPTraceExporter();
+    const processor = new import_sdk_trace_base.BatchSpanProcessor(exporter);
+    const provider = new import_sdk_trace_node.NodeTracerProvider({
+      resource: import_resources.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");
+
+// src/database.ts
+var import_ws = __toESM(require("ws"), 1);
+var import_node_fs = require("fs");
+var dbInstance = new import_node_async_hooks2.AsyncLocalStorage();
+var vitestDb = null;
+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");
+function useDatabase() {
+  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(useDatabase, "useDatabase");
+function createDatabaseClient(config = {}) {
+  const kyseleyConfig = {
+    dialect: getDialect(config.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 (process.env.DEBUG) {
+        if (event.level === "query") {
+          console.log(event.query.sql);
+          console.log(event.query.parameters);
+        }
+      }
+    }
+  };
+  return new import_kysely3.Kysely(kyseleyConfig);
+}
+__name(createDatabaseClient, "createDatabaseClient");
+var InstrumentedPool = class extends import_pg.Pool {
+  static {
+    __name(this, "InstrumentedPool");
+  }
+  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.apply(null, args);
+    });
+  }
+};
+var InstrumentedNeonServerlessPool = class extends neon.Pool {
+  static {
+    __name(this, "InstrumentedNeonServerlessPool");
+  }
+  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.apply(null, args);
+    });
+  }
+};
+var txStatements = {
+  begin: "Transaction Begin",
+  commit: "Transaction Commit",
+  rollback: "Transaction Rollback"
+};
+var InstrumentedClient = class extends import_pg.Client {
+  static {
+    __name(this, "InstrumentedClient");
+  }
+  async query(...args) {
+    const _super = super.query.bind(this);
+    const sql4 = args[0];
+    let sqlAttribute = false;
+    let spanName = txStatements[sql4.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.apply(null, args);
+    });
+  }
+};
+function getDialect(connString) {
+  const dbConnType = process.env.KEEL_DB_CONN_TYPE;
+  switch (dbConnType) {
+    case "pg": {
+      import_pg.types.setTypeParser(
+        import_pg.types.builtins.NUMERIC,
+        (val) => parseFloat(val)
+      );
+      import_pg.types.setTypeParser(
+        import_pg.types.builtins.INTERVAL,
+        (val) => new Duration(val)
+      );
+      const poolConfig = {
+        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
+      };
+      if (process.env.KEEL_DB_CERT) {
+        poolConfig.ssl = { ca: (0, import_node_fs.readFileSync)(process.env.KEEL_DB_CERT) };
+      }
+      return new import_kysely3.PostgresDialect({
+        pool: new InstrumentedPool(poolConfig)
+      });
+    }
+    case "neon": {
+      neon.types.setTypeParser(
+        import_pg.types.builtins.NUMERIC,
+        (val) => parseFloat(val)
+      );
+      neon.types.setTypeParser(
+        import_pg.types.builtins.INTERVAL,
+        (val) => new Duration(val)
+      );
+      neon.neonConfig.webSocketConstructor = import_ws.default;
+      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 sql4 = args[0];
+          let sqlAttribute = false;
+          let spanName = txStatements[sql4.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 import_kysely3.PostgresDialect({
+        pool
+      });
+    }
+    default:
+      throw Error("unexpected KEEL_DB_CONN_TYPE: " + dbConnType);
+  }
+}
+__name(getDialect, "getDialect");
+
+// src/File.ts
+var import_client_s3 = require("@aws-sdk/client-s3");
+var import_credential_providers = require("@aws-sdk/credential-providers");
+var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+
+// src/errors.js
+var import_json_rpc_2 = 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 extends Error {
+  static {
+    __name(this, "PermissionError");
+  }
+};
+var DatabaseError = class extends Error {
+  static {
+    __name(this, "DatabaseError");
+  }
+  constructor(error) {
+    super(error.message);
+    this.error = error;
+  }
+};
+var NotFoundError = class extends Error {
+  static {
+    __name(this, "NotFoundError");
+  }
+  errorCode = RuntimeErrors.RecordNotFoundError;
+  constructor(message) {
+    super(message);
+  }
+};
+var BadRequestError = class extends Error {
+  static {
+    __name(this, "BadRequestError");
+  }
+  errorCode = RuntimeErrors.BadRequestError;
+  constructor(message = "bad request") {
+    super(message);
+  }
+};
+var UnknownError = class extends Error {
+  static {
+    __name(this, "UnknownError");
+  }
+  errorCode = RuntimeErrors.UnknownError;
+  constructor(message = "unknown error") {
+    super(message);
+  }
+};
+var ErrorPresets = {
+  NotFound: NotFoundError,
+  BadRequest: BadRequestError,
+  Unknown: UnknownError
+};
+function errorToJSONRPCResponse(request, e) {
+  switch (e.constructor.name) {
+    case "PermissionError":
+      return (0, import_json_rpc_2.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 (0, import_json_rpc_2.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 (0, import_json_rpc_2.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: code2, detail, table: table2 } = err;
+        let rpcErrorCode, column, value;
+        const [col, val] = parseKeyMessage(err.detail);
+        column = col;
+        value = val;
+        switch (code2) {
+          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 (0, import_json_rpc_2.createJSONRPCErrorResponse)(request.id, rpcErrorCode, e.message, {
+          table: table2,
+          column,
+          code: code2,
+          detail,
+          value
+        });
+      }
+      return (0, import_json_rpc_2.createJSONRPCErrorResponse)(
+        request.id,
+        RuntimeErrors.DatabaseError,
+        e.message
+      );
+    default:
+      return (0, import_json_rpc_2.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");
+
+// src/File.ts
+var import_ksuid = __toESM(require("ksuid"), 1);
+var s3Client = (() => {
+  if (!process.env.KEEL_FILES_BUCKET_NAME) {
+    return null;
+  }
+  const endpoint = process.env.TEST_AWS_ENDPOINT;
+  if (!endpoint) {
+    return new import_client_s3.S3Client({
+      region: process.env.KEEL_REGION,
+      credentials: (0, import_credential_providers.fromEnv)()
+    });
+  }
+  return new import_client_s3.S3Client({
+    region: process.env.KEEL_REGION,
+    credentials: {
+      accessKeyId: "test",
+      secretAccessKey: "test"
+    },
+    endpointProvider: /* @__PURE__ */ __name(() => {
+      return {
+        url: new URL(endpoint)
+      };
+    }, "endpointProvider")
+  });
+})();
+var InlineFile = class _InlineFile {
+  static {
+    __name(this, "InlineFile");
+  }
+  constructor(input) {
+    this._filename = input.filename;
+    this._contentType = input.contentType;
+    this._contents = null;
+  }
+  static fromDataURL(dataURL) {
+    const info = dataURL.split(",")[0].split(":")[1];
+    const data = dataURL.split(",")[1];
+    const mime = info.split(";")[0];
+    const name = info.split(";")[1].split("=")[1];
+    const buffer = Buffer.from(data, "base64");
+    const file = new _InlineFile({ filename: name, contentType: mime });
+    file.write(buffer);
+    return file;
+  }
+  // Gets size of the file's contents in bytes
+  get size() {
+    if (this._contents) {
+      return this._contents.size;
+    }
+    return 0;
+  }
+  // Gets the media type of the file contents
+  get contentType() {
+    return this._contentType;
+  }
+  // Gets the name of the file
+  get filename() {
+    return this._filename;
+  }
+  // Write the files contents from a buffer
+  write(buffer) {
+    this._contents = new Blob([buffer]);
+  }
+  // Reads the contents of the file as a buffer
+  async read() {
+    if (!this._contents) {
+      throw new Error("No contents to read");
+    }
+    const arrayBuffer = await this._contents.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+  }
+  // Persists the file
+  async store(expires = null) {
+    const content = await this.read();
+    const key = import_ksuid.default.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
+    });
+  }
+};
+var File = class _File extends InlineFile {
+  static {
+    __name(this, "File");
+  }
+  constructor(input) {
+    super({
+      filename: input.filename || "",
+      contentType: input.contentType || ""
+    });
+    this._key = input.key || "";
+    this._size = input.size || 0;
+  }
+  // Creates a new instance from the database record
+  static fromDbRecord(input) {
+    return new _File({
+      key: input.key,
+      filename: input.filename,
+      size: input.size,
+      contentType: input.contentType
+    });
+  }
+  get size() {
+    return this._size;
+  }
+  // Gets the stored key
+  get key() {
+    return this._key;
+  }
+  get isPublic() {
+    return false;
+  }
+  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 import_client_s3.GetObjectCommand(params);
+      const response = await s3Client.send(command);
+      const blob = await response.Body.transformToByteArray();
+      return Buffer.from(blob);
+    }
+    const db = useDatabase();
+    try {
+      const 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,
+        this.size,
+        expires
+      );
+    }
+    return this;
+  }
+  // Generates a presigned download URL
+  async getPresignedUrl() {
+    if (s3Client) {
+      const command = new import_client_s3.GetObjectCommand({
+        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
+        Key: "files/" + this.key,
+        ResponseContentDisposition: "inline"
+      });
+      const url = await (0, import_s3_request_presigner.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);
+    }
+  }
+  // Persists the file
+  toDbRecord() {
+    return {
+      key: this.key,
+      filename: this.filename,
+      contentType: this.contentType,
+      size: this.size
+    };
+  }
+  toJSON() {
+    return this.toDbRecord();
+  }
+};
+async function storeFile(contents, key, filename, contentType, size, 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 import_client_s3.PutObjectCommand(params);
+    try {
+      await s3Client.send(command);
+    } catch (error) {
+      console.error("Error uploading file:", error);
+      throw error;
+    }
+  } else {
+    const db = useDatabase();
+    try {
+      const 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");
+
+// src/parsing.js
+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");
+
+// src/applyWhereConditions.js
+var import_kysely4 = require("kysely");
+
+// src/casing.js
+var import_change_case = require("change-case");
+function camelCaseObject(obj = {}) {
+  const r = {};
+  for (const key of Object.keys(obj)) {
+    r[(0, import_change_case.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[(0, import_change_case.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 = (0, import_change_case.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");
+
+// src/TimePeriod.js
+var TimePeriod = class _TimePeriod {
+  static {
+    __name(this, "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?.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 sql4 = "NOW()";
+    if (this.offset !== 0) {
+      sql4 = `${sql4} + INTERVAL '${this.offset} ${this.period}'`;
+    }
+    if (this.complete) {
+      sql4 = `DATE_TRUNC('${this.period}', ${sql4})`;
+    } else {
+      sql4 = `(${sql4})`;
+    }
+    return sql4;
+  }
+  periodEndSQL() {
+    let sql4 = this.periodStartSQL();
+    if (this.value != 0) {
+      sql4 = `(${sql4} + INTERVAL '${this.value} ${this.period}')`;
+    }
+    return sql4;
+  }
+};
+
+// src/applyWhereConditions.js
+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) => import_kysely4.sql`ANY(${v})`, "value") },
+  greaterThan: { op: ">" },
+  greaterThanOrEquals: { op: ">=" },
+  lessThan: { op: "<" },
+  lessThanOrEquals: { op: "<=" },
+  before: { op: "<" },
+  onOrBefore: { op: "<=" },
+  after: { op: ">" },
+  onOrAfter: { op: ">=" },
+  equals: { op: import_kysely4.sql`is not distinct from` },
+  notEquals: { op: import_kysely4.sql`is distinct from` },
+  equalsRelative: {
+    op: import_kysely4.sql`BETWEEN`,
+    value: /* @__PURE__ */ __name((v) => import_kysely4.sql`${import_kysely4.sql.raw(
+      TimePeriod.fromExpression(v).periodStartSQL()
+    )} AND ${import_kysely4.sql.raw(TimePeriod.fromExpression(v).periodEndSQL())}`, "value")
+  },
+  beforeRelative: {
+    op: "<",
+    value: /* @__PURE__ */ __name((v) => import_kysely4.sql`${import_kysely4.sql.raw(TimePeriod.fromExpression(v).periodStartSQL())}`, "value")
+  },
+  afterRelative: {
+    op: ">=",
+    value: /* @__PURE__ */ __name((v) => import_kysely4.sql`${import_kysely4.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) => import_kysely4.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) => import_kysely4.sql`NOT ${v}`, "value") }
+  }
+};
+function applyWhereConditions(context6, qb, where = {}) {
+  const conf = context6.tableConfig();
+  for (const key of Object.keys(where)) {
+    const v = where[key];
+    if (conf && conf[(0, import_change_case.snakeCase)(key)]) {
+      const rel = conf[(0, import_change_case.snakeCase)(key)];
+      context6.withJoin(rel.referencesTable, () => {
+        qb = applyWhereConditions(context6, qb, v);
+      });
+      continue;
+    }
+    const fieldName = `${context6.tableAlias()}.${(0, import_change_case.snakeCase)(key)}`;
+    if (Object.prototype.toString.call(v) !== "[object Object]") {
+      qb = qb.where(fieldName, import_kysely4.sql`is not distinct from`, import_kysely4.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]) : import_kysely4.sql`${v[op][arrayOp]}`,
+            mapping[arrayOp].op,
+            import_kysely4.sql`${(0, import_kysely4.sql)(op)}(${import_kysely4.sql.ref(fieldName)})`
+          );
+        }
+      } else {
+        qb = qb.where(
+          fieldName,
+          mapping.op,
+          mapping.value ? mapping.value(v[op]) : import_kysely4.sql`${v[op]}`
+        );
+      }
+    }
+  }
+  return qb;
+}
+__name(applyWhereConditions, "applyWhereConditions");
+
+// src/applyAdditionalQueryConstraints.js
+function applyLimit(context6, qb, limit) {
+  return qb.limit(limit);
+}
+__name(applyLimit, "applyLimit");
+function applyOffset(context6, qb, offset) {
+  return qb.offset(offset);
+}
+__name(applyOffset, "applyOffset");
+function applyOrderBy(context6, qb, tableName, orderBy = {}) {
+  Object.entries(orderBy).forEach(([key, sortOrder]) => {
+    qb = qb.orderBy(`${tableName}.${(0, import_change_case.snakeCase)(key)}`, sortOrder.toLowerCase());
+  });
+  return qb;
+}
+__name(applyOrderBy, "applyOrderBy");
+
+// src/applyJoins.js
+function applyJoins(context6, qb, where) {
+  const conf = context6.tableConfig();
+  if (!conf) {
+    return qb;
+  }
+  const srcTable = context6.tableAlias();
+  for (const key of Object.keys(where)) {
+    const rel = conf[(0, import_change_case.snakeCase)(key)];
+    if (!rel) {
+      continue;
+    }
+    const targetTable = rel.referencesTable;
+    if (context6.hasJoin(targetTable)) {
+      continue;
+    }
+    context6.withJoin(targetTable, () => {
+      switch (rel.relationshipType) {
+        case "hasMany":
+          qb = qb.innerJoin(
+            `${targetTable} as ${context6.tableAlias()}`,
+            `${srcTable}.id`,
+            `${context6.tableAlias()}.${rel.foreignKey}`
+          );
+          break;
+        case "belongsTo":
+          qb = qb.innerJoin(
+            `${targetTable} as ${context6.tableAlias()}`,
+            `${srcTable}.${rel.foreignKey}`,
+            `${context6.tableAlias()}.id`
+          );
+          break;
+        default:
+          throw new Error(`unknown relationshipType: ${rel.relationshipType}`);
+      }
+      qb = applyJoins(context6, qb, where[key]);
+    });
+  }
+  return qb;
+}
+__name(applyJoins, "applyJoins");
+
+// src/QueryContext.js
+var QueryContext = class _QueryContext {
+  static {
+    __name(this, "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()];
+  }
+};
+function joinAlias(tablePath) {
+  return tablePath.join("$");
+}
+__name(joinAlias, "joinAlias");
+
+// src/QueryBuilder.js
+var QueryBuilder = class _QueryBuilder {
+  static {
+    __name(this, "QueryBuilder");
+  }
+  /**
+   * @param {string} tableName
+   * @param {import("./QueryContext").QueryContext} context
+   * @param {import("kysely").Kysely} db
+   */
+  constructor(tableName, context6, db) {
+    this._tableName = tableName;
+    this._context = context6;
+    this._db = db;
+    this._modelName = upperCamelCase(this._tableName);
+  }
+  where(where) {
+    const context6 = this._context.clone();
+    let builder = applyJoins(context6, this._db, where);
+    builder = applyWhereConditions(context6, builder, where);
+    return new _QueryBuilder(this._tableName, context6, builder);
+  }
+  sql() {
+    return this._db.compile().sql;
+  }
+  async update(values) {
+    const name = spanNameForModelAPI(this._modelName, "update");
+    const db = useDatabase();
+    return 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 = spanNameForModelAPI(this._modelName, "delete");
+    const db = useDatabase();
+    return 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 = spanNameForModelAPI(this._modelName, "findOne");
+    const db = useDatabase();
+    return 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 = spanNameForModelAPI(this._modelName, "findMany");
+    const db = useDatabase();
+    return withSpan(name, async (span) => {
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      let builder = db.selectFrom((qb) => {
+        return this._db.as(this._tableName);
+      }).selectAll();
+      if (params?.limit) {
+        builder = applyLimit(context6, builder, params.limit);
+      }
+      if (params?.offset) {
+        builder = applyOffset(context6, builder, params.offset);
+      }
+      if (params?.orderBy !== void 0 && Object.keys(params?.orderBy).length > 0) {
+        builder = applyOrderBy(
+          context6,
+          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)));
+    });
+  }
+};
+
+// src/ModelAPI.js
+var ModelAPI = class {
+  static {
+    __name(this, "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 = spanNameForModelAPI(this._modelName, "create");
+    return withSpan(name, () => {
+      const db = useDatabase();
+      return create(
+        db,
+        this._tableName,
+        this._tableConfigMap,
+        snakeCaseObject(values)
+      );
+    });
+  }
+  async findOne(where = {}) {
+    const name = spanNameForModelAPI(this._modelName, "findOne");
+    const db = useDatabase();
+    return withSpan(name, async (span) => {
+      let builder = db.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      builder = applyJoins(context6, builder, where);
+      builder = applyWhereConditions(context6, 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 = spanNameForModelAPI(this._modelName, "findMany");
+    const db = useDatabase();
+    const where = params?.where || {};
+    return withSpan(name, async (span) => {
+      const context6 = 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(context6, builder2, where);
+        builder2 = applyWhereConditions(context6, builder2, where);
+        builder2 = builder2.as(this._tableName);
+        return builder2;
+      }).selectAll();
+      if (params?.limit) {
+        builder = applyLimit(context6, builder, params.limit);
+      }
+      if (params?.offset) {
+        builder = applyOffset(context6, builder, params.offset);
+      }
+      if (params?.orderBy !== void 0 && Object.keys(params?.orderBy).length > 0) {
+        builder = applyOrderBy(
+          context6,
+          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 = spanNameForModelAPI(this._modelName, "update");
+    const db = useDatabase();
+    return 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 context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      builder = applyWhereConditions(context6, 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 = spanNameForModelAPI(this._modelName, "delete");
+    const db = useDatabase();
+    return withSpan(name, async (span) => {
+      let builder = db.deleteFrom(this._tableName).returning(["id"]);
+      const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+      builder = applyWhereConditions(context6, 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 = useDatabase();
+    let builder = db.selectFrom(this._tableName).distinctOn(`${this._tableName}.id`).selectAll(this._tableName);
+    const context6 = new QueryContext([this._tableName], this._tableConfigMap);
+    builder = applyJoins(context6, builder, where);
+    builder = applyWhereConditions(context6, builder, where);
+    return new QueryBuilder(this._tableName, context6, builder);
+  }
+};
+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(import_kysely5.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");
+
+// src/RequestHeaders.ts
+var RequestHeaders = class {
+  /**
+   * @param {{Object.<string, string>}} requestHeaders Map of request headers submitted from the client
+   */
+  constructor(requestHeaders) {
+    this.get = /* @__PURE__ */ __name((key) => {
+      return this._headers.get(key);
+    }, "get");
+    this.has = /* @__PURE__ */ __name((key) => {
+      return this._headers.has(key);
+    }, "has");
+    this._headers = new Headers(requestHeaders);
+  }
+  static {
+    __name(this, "RequestHeaders");
+  }
+};
+
+// src/handleRequest.js
+var import_json_rpc_22 = require("json-rpc-2.0");
+
+// src/permissions.ts
+var import_async_hooks = require("async_hooks");
+var PERMISSION_STATE = {
+  UNKNOWN: "unknown",
+  PERMITTED: "permitted",
+  UNPERMITTED: "unpermitted"
+};
+var Permissions = class {
+  static {
+    __name(this, "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.
+  /**
+   * Explicitly permit access to an action
+   */
+  allow() {
+    permissionsApiInstance.getStore().permitted = true;
+  }
+  /**
+   * Explicitly deny access to an action
+   */
+  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;
+      default:
+        return PERMISSION_STATE.UNKNOWN;
+    }
+  }
+};
+var permissionsApiInstance = new import_async_hooks.AsyncLocalStorage();
+var withPermissions = /* @__PURE__ */ __name(async (initialValue, cb) => {
+  const permissions = new Permissions();
+  return await permissionsApiInstance.run({ permitted: initialValue }, () => {
+    return cb({ getPermissionState: permissions.getState });
+  });
+}, "withPermissions");
+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");
+
+// src/consts.js
+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"
+};
+
+// src/tryExecuteFunction.js
+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?.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");
+
+// src/handleRequest.js
+var opentelemetry2 = __toESM(require("@opentelemetry/api"), 1);
+async function handleRequest(request, config) {
+  const activeContext = opentelemetry2.propagation.extract(
+    opentelemetry2.context.active(),
+    request.meta?.tracing
+  );
+  if (process.env.KEEL_LOG_LEVEL == "debug") {
+    console.log(request);
+  }
+  return opentelemetry2.context.with(activeContext, () => {
+    return withSpan(request.method, async (span) => {
+      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: opentelemetry2.SpanStatusCode.ERROR,
+            message
+          });
+          return (0, import_json_rpc_22.createJSONRPCErrorResponse)(
+            request.id,
+            import_json_rpc_22.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: request.meta?.secrets?.KEEL_DB_CONN
+        });
+        const customFunction = functions[request.method];
+        const actionType = actionTypes[request.method];
+        const functionConfig = 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: opentelemetry2.SpanStatusCode.ERROR,
+            message: result.message
+          });
+          return errorToJSONRPCResponse(request, result);
+        }
+        const response = (0, import_json_rpc_22.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: opentelemetry2.SpanStatusCode.ERROR,
+            message: e.message
+          });
+          return errorToJSONRPCResponse(request, e);
+        }
+        const message = JSON.stringify(e);
+        span.setStatus({
+          code: opentelemetry2.SpanStatusCode.ERROR,
+          message
+        });
+        return (0, import_json_rpc_22.createJSONRPCErrorResponse)(
+          request.id,
+          RuntimeErrors.UnknownError,
+          message
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+__name(handleRequest, "handleRequest");
+
+// src/handleJob.js
+var import_json_rpc_23 = require("json-rpc-2.0");
+var opentelemetry3 = __toESM(require("@opentelemetry/api"), 1);
+
+// src/tryExecuteJob.js
+function tryExecuteJob({ db, permitted, request, functionConfig }, cb) {
+  return withPermissions(permitted, async ({ getPermissionState }) => {
+    let requiresTransaction = false;
+    if (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");
+
+// src/handleJob.js
+async function handleJob(request, config) {
+  const activeContext = opentelemetry3.propagation.extract(
+    opentelemetry3.context.active(),
+    request.meta?.tracing
+  );
+  return opentelemetry3.context.with(activeContext, () => {
+    return withSpan(request.method, async (span) => {
+      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: opentelemetry3.SpanStatusCode.ERROR,
+            message
+          });
+          return (0, import_json_rpc_23.createJSONRPCErrorResponse)(
+            request.id,
+            import_json_rpc_23.JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+        const ctx = createJobContextAPI({
+          meta: request.meta
+        });
+        const permitted = request.meta && request.meta.permissionState.status === "granted" ? true : null;
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN
+        });
+        const jobFunction = jobs[request.method];
+        const actionType = PROTO_ACTION_TYPES.JOB;
+        const functionConfig = jobFunction?.config ?? {};
+        await tryExecuteJob(
+          { request, permitted, db, actionType, functionConfig },
+          async () => {
+            const inputs = parseInputs(request.params);
+            return jobFunction(ctx, inputs);
+          }
+        );
+        return (0, import_json_rpc_23.createJSONRPCSuccessResponse)(request.id, null);
+      } catch (e) {
+        if (e instanceof Error) {
+          span.recordException(e);
+          span.setStatus({
+            code: opentelemetry3.SpanStatusCode.ERROR,
+            message: e.message
+          });
+          return errorToJSONRPCResponse(request, e);
+        }
+        const message = JSON.stringify(e);
+        span.setStatus({
+          code: opentelemetry3.SpanStatusCode.ERROR,
+          message
+        });
+        return (0, import_json_rpc_23.createJSONRPCErrorResponse)(
+          request.id,
+          RuntimeErrors.UnknownError,
+          message
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+__name(handleJob, "handleJob");
+
+// src/handleSubscriber.js
+var import_json_rpc_24 = require("json-rpc-2.0");
+var opentelemetry4 = __toESM(require("@opentelemetry/api"), 1);
+
+// src/tryExecuteSubscriber.js
+function tryExecuteSubscriber({ request, db, functionConfig }, cb) {
+  let requiresTransaction = false;
+  if (functionConfig?.dbTransaction !== void 0) {
+    requiresTransaction = functionConfig.dbTransaction;
+  }
+  return withDatabase(db, requiresTransaction, async () => {
+    await withAuditContext(request, async () => {
+      return cb();
+    });
+  });
+}
+__name(tryExecuteSubscriber, "tryExecuteSubscriber");
+
+// src/handleSubscriber.js
+async function handleSubscriber(request, config) {
+  const activeContext = opentelemetry4.propagation.extract(
+    opentelemetry4.context.active(),
+    request.meta?.tracing
+  );
+  return opentelemetry4.context.with(activeContext, () => {
+    return withSpan(request.method, async (span) => {
+      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: opentelemetry4.SpanStatusCode.ERROR,
+            message
+          });
+          return (0, import_json_rpc_24.createJSONRPCErrorResponse)(
+            request.id,
+            import_json_rpc_24.JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+        const ctx = createSubscriberContextAPI({
+          meta: request.meta
+        });
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.KEEL_DB_CONN
+        });
+        const subscriberFunction = subscribers[request.method];
+        const actionType = PROTO_ACTION_TYPES.SUBSCRIBER;
+        const functionConfig = subscriberFunction?.config ?? {};
+        await tryExecuteSubscriber(
+          { request, db, actionType, functionConfig },
+          async () => {
+            const inputs = parseInputs(request.params);
+            return subscriberFunction(ctx, inputs);
+          }
+        );
+        return (0, import_json_rpc_24.createJSONRPCSuccessResponse)(request.id, null);
+      } catch (e) {
+        if (e instanceof Error) {
+          span.recordException(e);
+          span.setStatus({
+            code: opentelemetry4.SpanStatusCode.ERROR,
+            message: e.message
+          });
+          return errorToJSONRPCResponse(request, e);
+        }
+        const message = JSON.stringify(e);
+        span.setStatus({
+          code: opentelemetry4.SpanStatusCode.ERROR,
+          message
+        });
+        return (0, import_json_rpc_24.createJSONRPCErrorResponse)(
+          request.id,
+          RuntimeErrors.UnknownError,
+          message
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+__name(handleSubscriber, "handleSubscriber");
+
+// src/handleRoute.js
+var import_json_rpc_25 = require("json-rpc-2.0");
+var opentelemetry5 = __toESM(require("@opentelemetry/api"), 1);
+async function handleRoute(request, config) {
+  const activeContext = opentelemetry5.propagation.extract(
+    opentelemetry5.context.active(),
+    request.meta?.tracing
+  );
+  return opentelemetry5.context.with(activeContext, () => {
+    return withSpan(request.method, async (span) => {
+      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: opentelemetry5.SpanStatusCode.ERROR,
+            message
+          });
+          return (0, import_json_rpc_25.createJSONRPCErrorResponse)(
+            request.id,
+            import_json_rpc_25.JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+        const {
+          headers,
+          response: __,
+          ...ctx
+        } = createContextAPI({
+          responseHeaders: new Headers(),
+          meta: request.meta
+        });
+        request.params.headers = headers;
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.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: opentelemetry5.SpanStatusCode.ERROR,
+            message: result.message
+          });
+          return errorToJSONRPCResponse(request, result);
+        }
+        const response = (0, import_json_rpc_25.createJSONRPCSuccessResponse)(request.id, result);
+        return response;
+      } catch (e) {
+        if (e instanceof Error) {
+          span.recordException(e);
+          span.setStatus({
+            code: opentelemetry5.SpanStatusCode.ERROR,
+            message: e.message
+          });
+          return errorToJSONRPCResponse(request, e);
+        }
+        const message = JSON.stringify(e);
+        span.setStatus({
+          code: opentelemetry5.SpanStatusCode.ERROR,
+          message
+        });
+        return (0, import_json_rpc_25.createJSONRPCErrorResponse)(
+          request.id,
+          RuntimeErrors.UnknownError,
+          message
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+__name(handleRoute, "handleRoute");
+
+// src/handleFlow.js
+var import_json_rpc_26 = require("json-rpc-2.0");
+var opentelemetry6 = __toESM(require("@opentelemetry/api"), 1);
+
+// src/tryExecuteFlow.js
+function tryExecuteFlow(db, cb) {
+  return withDatabase(db, false, async () => {
+    return cb();
+  });
+}
+__name(tryExecuteFlow, "tryExecuteFlow");
+
+// src/flows/ui/elements/input/text.ts
+var textInput = /* @__PURE__ */ __name((name, options) => {
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.input.text",
+      name,
+      label: options?.label || name,
+      defaultValue: options?.defaultValue,
+      optional: options?.optional,
+      placeholder: options?.placeholder,
+      multiline: options?.multiline,
+      maxLength: options?.maxLength,
+      minLength: options?.minLength
+    },
+    validate: options?.validate,
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "textInput");
+
+// src/flows/ui/elements/input/number.ts
+var numberInput = /* @__PURE__ */ __name((name, options) => {
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.input.number",
+      name,
+      label: options?.label || name,
+      defaultValue: options?.defaultValue,
+      optional: options?.optional,
+      placeholder: options?.placeholder,
+      min: options?.min,
+      max: options?.max
+    },
+    validate: options?.validate,
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "numberInput");
+
+// src/flows/ui/elements/display/divider.ts
+var divider = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.divider"
+    }
+  };
+}, "divider");
+
+// src/flows/ui/elements/input/boolean.ts
+var booleanInput = /* @__PURE__ */ __name((name, options) => {
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.input.boolean",
+      name,
+      label: options?.label || name,
+      defaultValue: options?.defaultValue,
+      optional: options?.optional,
+      mode: options?.mode || "checkbox"
+    },
+    validate: options?.validate,
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "booleanInput");
+
+// src/flows/ui/elements/display/markdown.ts
+var markdown = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.markdown",
+      content: options?.content || ""
+    }
+  };
+}, "markdown");
+
+// src/flows/ui/elements/display/table.ts
+var table = /* @__PURE__ */ __name((options) => {
+  const filteredData = options.columns ? options.data.map((item) => {
+    return Object.fromEntries(
+      Object.entries(item).filter(
+        ([key]) => options.columns?.includes(key)
+      )
+    );
+  }) : options.data;
+  return {
+    uiConfig: {
+      __type: "ui.display.table",
+      data: filteredData || [],
+      columns: options.columns
+    }
+  };
+}, "table");
+
+// src/flows/ui/elements/select/one.ts
+var selectOne = /* @__PURE__ */ __name((name, options) => {
+  return {
+    __type: "input",
+    uiConfig: {
+      __type: "ui.select.one",
+      name,
+      label: options?.label || name,
+      defaultValue: options?.defaultValue,
+      optional: options?.optional,
+      options: options?.options || []
+    },
+    validate: options?.validate,
+    getData: /* @__PURE__ */ __name((x) => x, "getData")
+  };
+}, "selectOne");
+
+// src/flows/ui/page.ts
+var page = /* @__PURE__ */ __name((options) => {
+  const content = options.content;
+  const contentUiConfig = content.map((c) => c.uiConfig).filter(Boolean);
+  return {
+    __type: "ui.page",
+    stage: options.stage,
+    title: options.title,
+    description: options.description,
+    content: contentUiConfig,
+    actions: options.actions
+  };
+}, "page");
+
+// src/flows/disrupts.ts
+var FlowDisrupt = class {
+  static {
+    __name(this, "FlowDisrupt");
+  }
+  constructor() {
+  }
+};
+var UIRenderDisrupt = class extends FlowDisrupt {
+  constructor(stepId, contents) {
+    super();
+    this.stepId = stepId;
+    this.contents = contents;
+  }
+  static {
+    __name(this, "UIRenderDisrupt");
+  }
+};
+var StepCreatedDisrupt = class extends FlowDisrupt {
+  static {
+    __name(this, "StepCreatedDisrupt");
+  }
+  constructor() {
+    super();
+  }
+};
+var ExhuastedRetriesDisrupt = class extends FlowDisrupt {
+  static {
+    __name(this, "ExhuastedRetriesDisrupt");
+  }
+  constructor() {
+    super();
+  }
+};
+
+// src/flows/ui/elements/display/banner.ts
+var banner = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.banner",
+      title: options?.title || "",
+      description: options?.description || "",
+      mode: options?.mode || "info"
+    }
+  };
+}, "banner");
+
+// src/flows/ui/elements/display/image.ts
+var image = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.image",
+      url: options?.url || "",
+      alt: options?.alt,
+      size: options?.size,
+      title: options?.title
+    }
+  };
+}, "image");
+
+// src/flows/ui/elements/display/code.ts
+var code = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.code",
+      code: options?.code || "",
+      language: options?.language
+    }
+  };
+}, "code");
+
+// src/flows/ui/elements/display/grid.ts
+var grid = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.grid",
+      data: options.data.map((item) => {
+        const rendered = options.render(item);
+        return {
+          title: rendered.title,
+          description: rendered.description,
+          image: rendered.image
+        };
+      })
+    }
+  };
+}, "grid");
+
+// src/flows/ui/elements/display/list.ts
+var list = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.list",
+      data: options.data.map((item) => {
+        const rendered = options.render(item);
+        return {
+          title: rendered.title,
+          description: rendered.description,
+          image: rendered.image
+        };
+      })
+    }
+  };
+}, "list");
+
+// src/flows/ui/elements/display/header.ts
+var header = /* @__PURE__ */ __name((options) => {
+  return {
+    uiConfig: {
+      __type: "ui.display.header",
+      level: options?.level || 1,
+      title: options?.title || "",
+      description: options?.description || ""
+    }
+  };
+}, "header");
+
+// src/flows/index.ts
+var defaultOpts = {
+  maxRetries: 5,
+  timeoutInMs: 6e4
+};
+function createFlowContext(runId, data, spanId) {
+  return {
+    step: /* @__PURE__ */ __name(async (name, optionsOrFn, fn) => {
+      const options = typeof optionsOrFn === "function" ? {} : optionsOrFn;
+      const actualFn = typeof optionsOrFn === "function" ? optionsOrFn : fn;
+      const db = useDatabase();
+      const past = await db.selectFrom("keel_flow_step").where("run_id", "=", runId).where("name", "=", name).selectAll().execute();
+      const newSteps = past.filter((step) => step.status === "NEW" /* NEW */);
+      const completedSteps = past.filter(
+        (step) => step.status === "COMPLETED" /* COMPLETED */
+      );
+      const failedSteps = past.filter(
+        (step) => step.status === "FAILED" /* FAILED */
+      );
+      if (newSteps.length > 1) {
+        throw new Error("Multiple NEW steps found for the same step");
+      }
+      if (completedSteps.length > 1) {
+        throw new Error("Multiple completed steps found for the same step");
+      }
+      if (completedSteps.length > 1 && newSteps.length > 1) {
+        throw new Error(
+          "Multiple completed and new steps found for the same step"
+        );
+      }
+      if (completedSteps.length === 1) {
+        return completedSteps[0].value;
+      }
+      if (newSteps.length === 1) {
+        let result = null;
+        await db.updateTable("keel_flow_step").set({
+          startTime: /* @__PURE__ */ new Date()
+        }).where("id", "=", newSteps[0].id).returningAll().executeTakeFirst();
+        try {
+          result = await withTimeout(
+            actualFn(),
+            options.timeoutInMs ?? defaultOpts.timeoutInMs
+          );
+        } catch (e) {
+          await db.updateTable("keel_flow_step").set({
+            status: "FAILED" /* FAILED */,
+            spanId,
+            endTime: /* @__PURE__ */ new Date(),
+            error: e instanceof Error ? e.message : "An error occurred"
+          }).where("id", "=", newSteps[0].id).returningAll().executeTakeFirst();
+          if (failedSteps.length + 1 >= (options.maxRetries ?? defaultOpts.maxRetries)) {
+            throw new ExhuastedRetriesDisrupt();
+          }
+          await db.insertInto("keel_flow_step").values({
+            run_id: runId,
+            name,
+            stage: options.stage,
+            status: "NEW" /* NEW */,
+            type: "FUNCTION" /* FUNCTION */
+          }).returningAll().executeTakeFirst();
+          throw new StepCreatedDisrupt();
+        }
+        await db.updateTable("keel_flow_step").set({
+          status: "COMPLETED" /* COMPLETED */,
+          value: JSON.stringify(result),
+          spanId,
+          endTime: /* @__PURE__ */ new Date()
+        }).where("id", "=", newSteps[0].id).returningAll().executeTakeFirst();
+        return result;
+      }
+      await db.insertInto("keel_flow_step").values({
+        run_id: runId,
+        name,
+        stage: options.stage,
+        status: "NEW" /* NEW */,
+        type: "FUNCTION" /* FUNCTION */
+      }).returningAll().executeTakeFirst();
+      throw new StepCreatedDisrupt();
+    }, "step"),
+    ui: {
+      page: /* @__PURE__ */ __name(async (name, options) => {
+        const db = useDatabase();
+        let step = await db.selectFrom("keel_flow_step").where("run_id", "=", runId).where("name", "=", name).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,
+            stage: options.stage,
+            status: "PENDING" /* PENDING */,
+            type: "UI" /* UI */,
+            startTime: /* @__PURE__ */ new Date()
+          }).returningAll().executeTakeFirst();
+          throw new UIRenderDisrupt(step?.id, page(options));
+        }
+        if (!data) {
+          throw new UIRenderDisrupt(step?.id, page(options));
+        }
+        await db.updateTable("keel_flow_step").set({
+          status: "COMPLETED" /* COMPLETED */,
+          value: JSON.stringify(data),
+          spanId,
+          endTime: /* @__PURE__ */ new Date()
+        }).where("id", "=", step.id).returningAll().executeTakeFirst();
+        return data;
+      }, "page"),
+      inputs: {
+        text: textInput,
+        number: numberInput,
+        boolean: booleanInput
+      },
+      display: {
+        divider,
+        markdown,
+        table,
+        header,
+        banner,
+        image,
+        code,
+        grid,
+        list
+      },
+      select: {
+        one: selectOne
+      }
+    }
+  };
+}
+__name(createFlowContext, "createFlowContext");
+function wait(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+__name(wait, "wait");
+function withTimeout(promiseFn, timeout) {
+  return Promise.race([
+    promiseFn,
+    wait(timeout).then(() => {
+      throw new Error(`Step function timed out after ${timeout}ms`);
+    })
+  ]);
+}
+__name(withTimeout, "withTimeout");
+
+// src/handleFlow.js
+async function handleFlow(request, config) {
+  const activeContext = opentelemetry6.propagation.extract(
+    opentelemetry6.context.active(),
+    request.meta?.tracing
+  );
+  return opentelemetry6.context.with(activeContext, () => {
+    return withSpan(request.method, async (span) => {
+      let db = null;
+      let flowConfig = null;
+      const runId = request.meta?.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: opentelemetry6.SpanStatusCode.ERROR,
+            message
+          });
+          return (0, import_json_rpc_26.createJSONRPCErrorResponse)(
+            request.id,
+            import_json_rpc_26.JSONRPCErrorCode.MethodNotFound,
+            message
+          );
+        }
+        db = createDatabaseClient({
+          connString: request.meta?.secrets?.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 = createFlowContext(
+          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 (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
+          runId,
+          runCompleted: true,
+          config: flowConfig
+        });
+      } catch (e) {
+        if (e instanceof StepCreatedDisrupt) {
+          return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
+            runId,
+            runCompleted: false,
+            config: flowConfig
+          });
+        }
+        if (e instanceof UIRenderDisrupt) {
+          return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
+            runId,
+            stepId: e.stepId,
+            config: flowConfig,
+            ui: e.contents
+          });
+        }
+        span.recordException(e);
+        span.setStatus({
+          code: opentelemetry6.SpanStatusCode.ERROR,
+          message: e.message
+        });
+        if (e instanceof ExhuastedRetriesDisrupt) {
+          return (0, import_json_rpc_26.createJSONRPCSuccessResponse)(request.id, {
+            runId,
+            runCompleted: true,
+            error: "flow failed due to exhausted step retries",
+            config: flowConfig
+          });
+        }
+        return (0, import_json_rpc_26.createJSONRPCErrorResponse)(
+          request.id,
+          import_json_rpc_26.JSONRPCErrorCode.InternalError,
+          e.message
+        );
+      } finally {
+        if (db) {
+          await db.destroy();
+        }
+      }
+    });
+  });
+}
+__name(handleFlow, "handleFlow");
+
+// src/index.ts
+var import_ksuid2 = __toESM(require("ksuid"), 1);
+function ksuid() {
+  return import_ksuid2.default.randomSync().string;
+}
+__name(ksuid, "ksuid");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Duration,
+  ErrorPresets,
+  File,
+  InlineFile,
+  KSUID,
+  ModelAPI,
+  PERMISSION_STATE,
+  Permissions,
+  RequestHeaders,
+  checkBuiltInPermissions,
+  createFlowContext,
+  handleFlow,
+  handleJob,
+  handleRequest,
+  handleRoute,
+  handleSubscriber,
+  ksuid,
+  tracing,
+  useDatabase
+});
+//# sourceMappingURL=index.cjs.map