@teamkeel/functions-runtime 0.412.0-next.8 → 0.412.1

package/dist/index.js

@@ -1,2747 +0,0 @@
-var __defProp = Object.defineProperty;
-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 });
-};
-
-// src/ModelAPI.js
-import { sql as sql3 } from "kysely";
-
-// src/database.ts
-import { Kysely, PostgresDialect } from "kysely";
-import * as neon from "@neondatabase/serverless";
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-
-// src/auditing.js
-import { AsyncLocalStorage } from "node:async_hooks";
-import TraceParent from "traceparent";
-import { sql, SelectionNode } from "kysely";
-var auditContextStorage = new 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 = TraceParent.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 = sql`set_identity_id(${audit.identityId})`.as(this.identityIdAlias).toOperationNode();
-          returning.selections.push(SelectionNode.create(rawNode));
-        }
-        if (audit.traceId) {
-          const rawNode = sql`set_trace_id(${audit.traceId})`.as(this.traceIdAlias).toOperationNode();
-          returning.selections.push(SelectionNode.create(rawNode));
-        }
-        return {
-          ...args.node,
-          returning
-        };
-    }
-    return {
-      ...args.node
-    };
-  }
-  // Drops the set_identity_id() and set_trace_id() fields from the result.
-  transformResult(args) {
-    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
-import { CamelCasePlugin } from "kysely";
-
-// src/Duration.ts
-import parseInterval from "postgres-interval";
-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 = parseInterval(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 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
-import { Pool as Pool2, Client, types as pgTypes } from "pg";
-
-// src/tracing.js
-var tracing_exports = {};
-__export(tracing_exports, {
-  forceFlush: () => forceFlush,
-  getTracer: () => getTracer,
-  init: () => init,
-  spanNameForModelAPI: () => spanNameForModelAPI,
-  withSpan: () => withSpan
-});
-import * as opentelemetry from "@opentelemetry/api";
-import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-base";
-import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-proto";
-import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
-import { envDetectorSync } from "@opentelemetry/resources";
-async function withSpan(name, fn) {
-  return getTracer().startActiveSpan(name, async (span) => {
-    try {
-      return await fn(span);
-    } catch (err) {
-      span.recordException(err);
-      span.setStatus({
-        code: opentelemetry.SpanStatusCode.ERROR,
-        message: err.message
-      });
-      throw err;
-    } finally {
-      span.end();
-    }
-  });
-}
-__name(withSpan, "withSpan");
-function patchFetch() {
-  if (!globalThis.fetch.patched) {
-    const originalFetch = globalThis.fetch;
-    globalThis.fetch = async (...args) => {
-      return withSpan("fetch", async (span) => {
-        const url = new URL(
-          args[0] instanceof Request ? args[0].url : String(args[0])
-        );
-        span.setAttribute("http.url", url.toString());
-        const scheme = url.protocol.replace(":", "");
-        span.setAttribute("http.scheme", scheme);
-        const options = args[0] instanceof Request ? args[0] : args[1] || {};
-        const method = (options.method || "GET").toUpperCase();
-        span.setAttribute("http.method", method);
-        const res = await originalFetch(...args);
-        span.setAttribute("http.status", res.status);
-        span.setAttribute("http.status_text", res.statusText);
-        return res;
-      });
-    };
-    globalThis.fetch.patched = true;
-  }
-}
-__name(patchFetch, "patchFetch");
-function patchConsoleLog() {
-  if (!console.log.patched) {
-    const originalConsoleLog = console.log;
-    console.log = (...args) => {
-      const span = opentelemetry.trace.getActiveSpan();
-      if (span) {
-        const output = args.map((arg) => {
-          if (arg instanceof Error) {
-            return arg.stack;
-          }
-          if (typeof arg === "object") {
-            try {
-              return JSON.stringify(arg, getCircularReplacer());
-            } catch (error) {
-              return "[Object with circular references]";
-            }
-          }
-          if (typeof arg === "function") {
-            return arg() || arg.name || arg.toString();
-          }
-          return String(arg);
-        }).join(" ");
-        span.addEvent(output);
-      }
-      originalConsoleLog(...args);
-    };
-    console.log.patched = true;
-  }
-}
-__name(patchConsoleLog, "patchConsoleLog");
-function patchConsoleError() {
-  if (!console.error.patched) {
-    const originalConsoleError = console.error;
-    console.error = (...args) => {
-      const span = opentelemetry.trace.getActiveSpan();
-      if (span) {
-        const output = args.map((arg) => {
-          if (arg instanceof Error) {
-            return arg.stack;
-          }
-          if (typeof arg === "object") {
-            try {
-              return JSON.stringify(arg, getCircularReplacer());
-            } catch (error) {
-              return "[Object with circular references]";
-            }
-          }
-          if (typeof arg === "function") {
-            return arg() || arg.name || arg.toString();
-          }
-          return String(arg);
-        }).join(" ");
-        span.setStatus({
-          code: opentelemetry.SpanStatusCode.ERROR,
-          message: output
-        });
-      }
-      originalConsoleError(...args);
-    };
-    console.error.patched = true;
-  }
-}
-__name(patchConsoleError, "patchConsoleError");
-function getCircularReplacer() {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return (key, value) => {
-    if (typeof value === "object" && value !== null) {
-      if (seen.has(value)) {
-        return "[Circular]";
-      }
-      seen.add(value);
-    }
-    return value;
-  };
-}
-__name(getCircularReplacer, "getCircularReplacer");
-function init() {
-  if (process.env.KEEL_TRACING_ENABLED == "true") {
-    const exporter = new OTLPTraceExporter();
-    const processor = new BatchSpanProcessor(exporter);
-    const provider = new NodeTracerProvider({
-      resource: envDetectorSync.detect(),
-      spanProcessors: [processor]
-    });
-    provider.register();
-  }
-  patchFetch();
-  patchConsoleLog();
-  patchConsoleError();
-}
-__name(init, "init");
-async function forceFlush() {
-  const provider = opentelemetry.trace.getTracerProvider().getDelegate();
-  if (provider && provider.forceFlush) {
-    await provider.forceFlush();
-  }
-}
-__name(forceFlush, "forceFlush");
-function getTracer() {
-  return opentelemetry.trace.getTracer("functions");
-}
-__name(getTracer, "getTracer");
-function spanNameForModelAPI(modelName, action) {
-  return `Database ${modelName}.${action}`;
-}
-__name(spanNameForModelAPI, "spanNameForModelAPI");
-
-// src/database.ts
-import WebSocket from "ws";
-import { readFileSync } from "node:fs";
-var dbInstance = new AsyncLocalStorage2();
-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 Kysely(kyseleyConfig);
-}
-__name(createDatabaseClient, "createDatabaseClient");
-var InstrumentedPool = class extends Pool2 {
-  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 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": {
-      pgTypes.setTypeParser(
-        pgTypes.builtins.NUMERIC,
-        (val) => parseFloat(val)
-      );
-      pgTypes.setTypeParser(
-        pgTypes.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: readFileSync(process.env.KEEL_DB_CERT) };
-      }
-      return new PostgresDialect({
-        pool: new InstrumentedPool(poolConfig)
-      });
-    }
-    case "neon": {
-      neon.types.setTypeParser(
-        pgTypes.builtins.NUMERIC,
-        (val) => parseFloat(val)
-      );
-      neon.types.setTypeParser(
-        pgTypes.builtins.INTERVAL,
-        (val) => new Duration(val)
-      );
-      neon.neonConfig.webSocketConstructor = WebSocket;
-      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 PostgresDialect({
-        pool
-      });
-    }
-    default:
-      throw Error("unexpected KEEL_DB_CONN_TYPE: " + dbConnType);
-  }
-}
-__name(getDialect, "getDialect");
-
-// src/File.ts
-import {
-  S3Client,
-  PutObjectCommand,
-  GetObjectCommand
-} from "@aws-sdk/client-s3";
-import { fromEnv } from "@aws-sdk/credential-providers";
-import { getSignedUrl } from "@aws-sdk/s3-request-presigner";
-
-// src/errors.js
-import { createJSONRPCErrorResponse } from "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 createJSONRPCErrorResponse(
-        request.id,
-        RuntimeErrors.PermissionError,
-        e.message
-      );
-    // Any error thrown in the ModelAPI class is
-    // wrapped in a DatabaseError in order to differentiate 'our code' vs the user's own code.
-    case "NoResultError":
-      return createJSONRPCErrorResponse(
-        request.id,
-        // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
-        RuntimeErrors.RecordNotFoundError,
-        ""
-        // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
-      );
-    case "DatabaseError":
-      let err = e;
-      if (e instanceof DatabaseError) {
-        err = e.error;
-      }
-      if (err.constructor.name == "NoResultError") {
-        return createJSONRPCErrorResponse(
-          request.id,
-          // to be matched to https://github.com/teamkeel/keel/blob/e3115ffe381bfc371d4f45bbf96a15072a994ce5/runtime/actions/update.go#L54-L54
-          RuntimeErrors.RecordNotFoundError,
-          ""
-          // Don't pass on the message as we want to normalise these at the runtime layer but still support custom messages in other NotFound errors
-        );
-      }
-      if ("code" in err) {
-        const { code: 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 createJSONRPCErrorResponse(request.id, rpcErrorCode, e.message, {
-          table: table2,
-          column,
-          code: code2,
-          detail,
-          value
-        });
-      }
-      return createJSONRPCErrorResponse(
-        request.id,
-        RuntimeErrors.DatabaseError,
-        e.message
-      );
-    default:
-      return createJSONRPCErrorResponse(
-        request.id,
-        e.errorCode ?? RuntimeErrors.UnknownError,
-        e.message
-      );
-  }
-}
-__name(errorToJSONRPCResponse, "errorToJSONRPCResponse");
-var keyMessagePattern = /\Key\s[(](.*)[)][=][(](.*)[)]/;
-var parseKeyMessage = /* @__PURE__ */ __name((msg) => {
-  const [, col, value] = keyMessagePattern.exec(msg) || [];
-  return [col, value];
-}, "parseKeyMessage");
-
-// src/File.ts
-import KSUID from "ksuid";
-var s3Client = (() => {
-  if (!process.env.KEEL_FILES_BUCKET_NAME) {
-    return null;
-  }
-  const endpoint = process.env.TEST_AWS_ENDPOINT;
-  if (!endpoint) {
-    return new S3Client({
-      region: process.env.KEEL_REGION,
-      credentials: fromEnv()
-    });
-  }
-  return new S3Client({
-    region: process.env.KEEL_REGION,
-    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 = KSUID.randomSync().string;
-    await storeFile(
-      content,
-      key,
-      this._filename,
-      this._contentType,
-      this.size,
-      expires
-    );
-    return new File({
-      key,
-      size: this.size,
-      filename: this.filename,
-      contentType: this.contentType
-    });
-  }
-};
-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 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 GetObjectCommand({
-        Bucket: process.env.KEEL_FILES_BUCKET_NAME,
-        Key: "files/" + this.key,
-        ResponseContentDisposition: "inline"
-      });
-      const url = await getSignedUrl(s3Client, command, { expiresIn: 60 * 60 });
-      return new URL(url);
-    } else {
-      const contents = await this.read();
-      const dataurl = `data:${this.contentType};name=${this.filename};base64,${contents.toString("base64")}`;
-      return new URL(dataurl);
-    }
-  }
-  // 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 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
-import { sql as sql2 } from "kysely";
-
-// src/casing.js
-import { snakeCase, camelCase } from "change-case";
-function camelCaseObject(obj = {}) {
-  const r = {};
-  for (const key of Object.keys(obj)) {
-    r[camelCase(key, {
-      transform: camelCaseTransform,
-      splitRegexp: [
-        /([a-z0-9])([A-Z])/g,
-        /([A-Z])([A-Z][a-z])/g,
-        /([a-zA-Z])([0-9])/g
-      ]
-    })] = obj[key];
-  }
-  return r;
-}
-__name(camelCaseObject, "camelCaseObject");
-function snakeCaseObject(obj) {
-  const r = {};
-  for (const key of Object.keys(obj)) {
-    r[snakeCase(key, {
-      splitRegexp: [
-        /([a-z0-9])([A-Z])/g,
-        /([A-Z])([A-Z][a-z])/g,
-        /([a-zA-Z])([0-9])/g
-      ]
-    })] = obj[key];
-  }
-  return r;
-}
-__name(snakeCaseObject, "snakeCaseObject");
-function upperCamelCase(s) {
-  s = camelCase(s);
-  return s[0].toUpperCase() + s.substring(1);
-}
-__name(upperCamelCase, "upperCamelCase");
-function camelCaseTransform(input, index) {
-  if (index === 0) return input.toLowerCase();
-  const firstChar = input.charAt(0);
-  const lowerChars = input.substr(1).toLowerCase();
-  return `${firstChar.toUpperCase()}${lowerChars}`;
-}
-__name(camelCaseTransform, "camelCaseTransform");
-
-// 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) => sql2`ANY(${v})`, "value") },
-  greaterThan: { op: ">" },
-  greaterThanOrEquals: { op: ">=" },
-  lessThan: { op: "<" },
-  lessThanOrEquals: { op: "<=" },
-  before: { op: "<" },
-  onOrBefore: { op: "<=" },
-  after: { op: ">" },
-  onOrAfter: { op: ">=" },
-  equals: { op: sql2`is not distinct from` },
-  notEquals: { op: sql2`is distinct from` },
-  equalsRelative: {
-    op: sql2`BETWEEN`,
-    value: /* @__PURE__ */ __name((v) => sql2`${sql2.raw(
-      TimePeriod.fromExpression(v).periodStartSQL()
-    )} AND ${sql2.raw(TimePeriod.fromExpression(v).periodEndSQL())}`, "value")
-  },
-  beforeRelative: {
-    op: "<",
-    value: /* @__PURE__ */ __name((v) => sql2`${sql2.raw(TimePeriod.fromExpression(v).periodStartSQL())}`, "value")
-  },
-  afterRelative: {
-    op: ">=",
-    value: /* @__PURE__ */ __name((v) => sql2`${sql2.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) => sql2`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) => sql2`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[snakeCase(key)]) {
-      const rel = conf[snakeCase(key)];
-      context6.withJoin(rel.referencesTable, () => {
-        qb = applyWhereConditions(context6, qb, v);
-      });
-      continue;
-    }
-    const fieldName = `${context6.tableAlias()}.${snakeCase(key)}`;
-    if (Object.prototype.toString.call(v) !== "[object Object]") {
-      qb = qb.where(fieldName, sql2`is not distinct from`, sql2`${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]) : sql2`${v[op][arrayOp]}`,
-            mapping[arrayOp].op,
-            sql2`${sql2(op)}(${sql2.ref(fieldName)})`
-          );
-        }
-      } else {
-        qb = qb.where(
-          fieldName,
-          mapping.op,
-          mapping.value ? mapping.value(v[op]) : sql2`${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}.${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[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(sql3`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
-import {
-  createJSONRPCErrorResponse as createJSONRPCErrorResponse2,
-  createJSONRPCSuccessResponse,
-  JSONRPCErrorCode
-} from "json-rpc-2.0";
-
-// src/permissions.ts
-import { AsyncLocalStorage as AsyncLocalStorage3 } from "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 AsyncLocalStorage3();
-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
-import * as opentelemetry2 from "@opentelemetry/api";
-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 createJSONRPCErrorResponse2(
-            request.id,
-            JSONRPCErrorCode.MethodNotFound,
-            message
-          );
-        }
-        const headers = new Headers();
-        const ctx = createContextAPI({
-          responseHeaders: headers,
-          meta: request.meta
-        });
-        const permitted = request.meta && request.meta.permissionState.status === "granted" ? true : null;
-        db = createDatabaseClient({
-          connString: 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 = 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 createJSONRPCErrorResponse2(
-          request.id,
-          RuntimeErrors.UnknownError,
-          message
-        );
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-__name(handleRequest, "handleRequest");
-
-// src/handleJob.js
-import {
-  createJSONRPCErrorResponse as createJSONRPCErrorResponse3,
-  createJSONRPCSuccessResponse as createJSONRPCSuccessResponse2,
-  JSONRPCErrorCode as JSONRPCErrorCode2
-} from "json-rpc-2.0";
-import * as opentelemetry3 from "@opentelemetry/api";
-
-// 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 createJSONRPCErrorResponse3(
-            request.id,
-            JSONRPCErrorCode2.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 createJSONRPCSuccessResponse2(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 createJSONRPCErrorResponse3(
-          request.id,
-          RuntimeErrors.UnknownError,
-          message
-        );
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-__name(handleJob, "handleJob");
-
-// src/handleSubscriber.js
-import {
-  createJSONRPCErrorResponse as createJSONRPCErrorResponse4,
-  createJSONRPCSuccessResponse as createJSONRPCSuccessResponse3,
-  JSONRPCErrorCode as JSONRPCErrorCode3
-} from "json-rpc-2.0";
-import * as opentelemetry4 from "@opentelemetry/api";
-
-// 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 createJSONRPCErrorResponse4(
-            request.id,
-            JSONRPCErrorCode3.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 createJSONRPCSuccessResponse3(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 createJSONRPCErrorResponse4(
-          request.id,
-          RuntimeErrors.UnknownError,
-          message
-        );
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-__name(handleSubscriber, "handleSubscriber");
-
-// src/handleRoute.js
-import {
-  createJSONRPCErrorResponse as createJSONRPCErrorResponse5,
-  createJSONRPCSuccessResponse as createJSONRPCSuccessResponse4,
-  JSONRPCErrorCode as JSONRPCErrorCode4
-} from "json-rpc-2.0";
-import * as opentelemetry5 from "@opentelemetry/api";
-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 createJSONRPCErrorResponse5(
-            request.id,
-            JSONRPCErrorCode4.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 = createJSONRPCSuccessResponse4(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 createJSONRPCErrorResponse5(
-          request.id,
-          RuntimeErrors.UnknownError,
-          message
-        );
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-__name(handleRoute, "handleRoute");
-
-// src/handleFlow.js
-import {
-  createJSONRPCErrorResponse as createJSONRPCErrorResponse6,
-  createJSONRPCSuccessResponse as createJSONRPCSuccessResponse5,
-  JSONRPCErrorCode as JSONRPCErrorCode5
-} from "json-rpc-2.0";
-import * as opentelemetry6 from "@opentelemetry/api";
-
-// 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 {
-    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 {
-    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 {
-    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/single.ts
-var selectOne = /* @__PURE__ */ __name((name, options) => {
-  return {
-    uiConfig: {
-      __type: "ui.select.single",
-      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/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 StepErrorDisrupt = class extends FlowDisrupt {
-  constructor(message) {
-    super();
-    this.message = message;
-  }
-  static {
-    __name(this, "StepErrorDisrupt");
-  }
-};
-var StepCompletedDisrupt = class extends FlowDisrupt {
-  static {
-    __name(this, "StepCompletedDisrupt");
-  }
-  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(options.render)
-    }
-  };
-}, "grid");
-
-// src/flows/ui/elements/display/list.ts
-var list = /* @__PURE__ */ __name((options) => {
-  return {
-    uiConfig: {
-      __type: "ui.display.list",
-      data: options.data.map(options.render)
-    }
-  };
-}, "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, options, fn) => {
-      const db = useDatabase();
-      const completed = await db.selectFrom("keel_flow_step").where("run_id", "=", runId).where("name", "=", name).where("status", "=", "COMPLETED" /* COMPLETED */).selectAll().executeTakeFirst();
-      if (completed) {
-        return completed.value;
-      }
-      const step = await db.insertInto("keel_flow_step").values({
-        run_id: runId,
-        name,
-        stage: options.stage,
-        status: "NEW" /* NEW */,
-        type: "FUNCTION" /* FUNCTION */,
-        maxRetries: options?.maxRetries ?? defaultOpts.maxRetries,
-        timeoutInMs: options?.timeoutInMs ?? defaultOpts.timeoutInMs
-      }).returningAll().executeTakeFirst();
-      if (!step) {
-        throw new Error("Failed to create step");
-      }
-      let result = null;
-      try {
-        result = await withTimeout(fn(), step.timeoutInMs);
-      } catch (e) {
-        await db.updateTable("keel_flow_step").set({
-          status: "FAILED" /* FAILED */,
-          spanId
-          // TODO: store error message
-        }).where("id", "=", step.id).returningAll().executeTakeFirst();
-        throw new StepErrorDisrupt(
-          e instanceof Error ? e.message : "an error occurred"
-        );
-      }
-      await db.updateTable("keel_flow_step").set({
-        status: "COMPLETED" /* COMPLETED */,
-        value: JSON.stringify(result),
-        spanId
-      }).where("id", "=", step.id).returningAll().executeTakeFirst();
-      throw new StepCompletedDisrupt();
-    }, "step"),
-    ui: {
-      page: /* @__PURE__ */ __name(async (name, page) => {
-        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: page.stage,
-            status: "PENDING" /* PENDING */,
-            type: "UI" /* UI */,
-            maxRetries: 3,
-            timeoutInMs: 1e3
-          }).returningAll().executeTakeFirst();
-        }
-        if (!step) {
-          throw new Error("Failed to create step");
-        }
-        if (data) {
-          await db.updateTable("keel_flow_step").set({
-            status: "COMPLETED" /* COMPLETED */,
-            value: JSON.stringify(data),
-            spanId
-          }).where("id", "=", step.id).returningAll().executeTakeFirst();
-          return data;
-        } else {
-          throw new UIRenderDisrupt(step.id, page);
-        }
-      }, "page"),
-      inputs: {
-        text: textInput,
-        number: numberInput,
-        boolean: booleanInput
-      },
-      display: {
-        divider,
-        markdown,
-        table,
-        header,
-        banner,
-        image,
-        code,
-        grid,
-        list
-      },
-      select: {
-        single: 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(`flow times 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 createJSONRPCErrorResponse6(
-            request.id,
-            JSONRPCErrorCode5.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 createJSONRPCSuccessResponse5(request.id, {
-          runId,
-          runCompleted: true,
-          config: flowConfig
-        });
-      } catch (e) {
-        if (e instanceof StepCompletedDisrupt) {
-          return createJSONRPCSuccessResponse5(request.id, {
-            runId,
-            runCompleted: false,
-            config: flowConfig
-          });
-        }
-        if (e instanceof UIRenderDisrupt) {
-          return createJSONRPCSuccessResponse5(request.id, {
-            runId,
-            stepId: e.stepId,
-            config: flowConfig,
-            ui: e.contents
-          });
-        }
-        span.recordException(e);
-        span.setStatus({
-          code: opentelemetry6.SpanStatusCode.ERROR,
-          message: e.message
-        });
-        return createJSONRPCSuccessResponse5(request.id, {
-          runId,
-          runCompleted: false,
-          config: flowConfig
-        });
-      } finally {
-        if (db) {
-          await db.destroy();
-        }
-      }
-    });
-  });
-}
-__name(handleFlow, "handleFlow");
-
-// src/index.ts
-import KSUID2 from "ksuid";
-function ksuid() {
-  return KSUID2.randomSync().string;
-}
-__name(ksuid, "ksuid");
-export {
-  Duration,
-  ErrorPresets,
-  File,
-  InlineFile,
-  KSUID2 as KSUID,
-  ModelAPI,
-  PERMISSION_STATE,
-  Permissions,
-  RequestHeaders,
-  checkBuiltInPermissions,
-  createFlowContext,
-  handleFlow,
-  handleJob,
-  handleRequest,
-  handleRoute,
-  handleSubscriber,
-  ksuid,
-  tracing_exports as tracing,
-  useDatabase
-};
-//# sourceMappingURL=index.js.map