@getstrata/core 0.5.13 → 0.5.15

package/dist/entries/http/webErrorResponse.js

@@ -183,9 +183,6 @@ function isHtmxRequest(request) {
   return request.headers.get("HX-Request") === "true";
 }
 // ../../src/bootstrap/config.ts
-var CORE_QUEUE_TOKEN = "core.queue";
-var CORE_POLICY_GATE_TOKEN = "core.policyGate";
-var CORE_AUTH_TOKEN = "core.auth";
 var CORE_TOKEN_SERVICE_TOKEN = "core.tokenService";
 var DEFAULT_QUEUE_DRIVER = "sync";
 
@@ -494,14 +491,6 @@ function appendWhereParts(tableName, where, params) {
   }
   return clauses.join(" AND ");
 }
-function buildWhereClause(tableName, where = {}) {
-  const params = [];
-  const body = appendWhereParts(tableName, where, params);
-  return {
-    clause: body.length > 0 ? ` WHERE ${body}` : "",
-    params
-  };
-}
 function buildWhereNodeClause(tableName, node, params) {
   if ("where" in node) {
     return appendWhereParts(tableName, node.where, params);
@@ -804,30 +793,6 @@ function buildDeleteByIdQuery(table, id) {
 }
 
 // ../../src/core/database/relationships.ts
-function hasMany(definition) {
-  return {
-    type: "hasMany",
-    ...definition
-  };
-}
-function hasOne(definition) {
-  return {
-    type: "hasOne",
-    ...definition
-  };
-}
-function belongsTo(definition) {
-  return {
-    type: "belongsTo",
-    ...definition
-  };
-}
-function belongsToMany(definition) {
-  return {
-    type: "belongsToMany",
-    ...definition
-  };
-}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -843,15 +808,6 @@ function indexHasManyRelation(parents, children, relation) {
   }
   return groups;
 }
-function indexHasOneRelation(parents, children, relation) {
-  const grouped = indexHasManyRelation(parents, children, relation);
-  const result = new Map;
-  for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
-    result.set(parent[relation.localKey], matches[0]);
-  }
-  return result;
-}
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
@@ -867,45 +823,6 @@ function indexBelongsToRelation(children, parents, relation) {
   }
   return result;
 }
-function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
-  const relatedById = new Map;
-  for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
-  }
-  const groups = new Map;
-  for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
-  }
-  for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
-    if (!group || !related) {
-      continue;
-    }
-    group.push(related);
-  }
-  return groups;
-}
-function morphMany(definition) {
-  return {
-    type: "morphMany",
-    ...definition
-  };
-}
-function morphOne(definition) {
-  return {
-    type: "morphOne",
-    ...definition
-  };
-}
-function morphTo(definition) {
-  return {
-    type: "morphTo",
-    ...definition
-  };
-}
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
   for (const parent of parents) {
@@ -924,15 +841,6 @@ function indexMorphManyRelation(parents, children, relation) {
   }
   return groups;
 }
-function indexMorphOneRelation(parents, children, relation) {
-  const grouped = indexMorphManyRelation(parents, children, relation);
-  const result = new Map;
-  for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
-    result.set(parent[relation.localKey], matches[0]);
-  }
-  return result;
-}
 function indexMorphToRelation(children, parentsByType, relation) {
   const result = new Map;
   for (const child of children) {
@@ -949,92 +857,71 @@ function indexMorphToRelation(children, parentsByType, relation) {
   return result;
 }
 
-// ../../src/config/database.ts
-function readInteger(name, fallback) {
-  const parsed = Number.parseInt(process.env[name] ?? String(fallback), 10);
-  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
-}
-var databaseConfig = {
-  url: process.env.DATABASE_URL ?? "",
-  poolMax: readInteger("DB_POOL_MAX", 10),
-  idleTimeoutSeconds: readInteger("DB_POOL_IDLE_TIMEOUT", 30),
-  maxLifetimeSeconds: readInteger("DB_POOL_MAX_LIFETIME", 3600),
-  connectionTimeoutSeconds: readInteger("DB_CONNECTION_TIMEOUT", 10)
+// ../../src/core/database/boundConnection.ts
+var boundConnectionHolder = {
+  connection: null
 };
+function getBoundDatabaseConnection() {
+  return boundConnectionHolder.connection;
+}
 
 // ../../src/core/database/connectionContext.ts
 import { AsyncLocalStorage } from "async_hooks";
 var activeConnection = new AsyncLocalStorage;
-function runWithDatabaseConnection(connection, callback) {
-  return activeConnection.run(connection, callback);
-}
 function getActiveDatabaseConnection(fallback) {
   return activeConnection.getStore() ?? fallback;
 }
 
-// ../../src/db/connection/createConnection.ts
-var {SQL } = globalThis.Bun;
-function createDatabaseConnection(config) {
-  if (!config.url) {
-    throw new Error("DATABASE_URL is not configured. Set DATABASE_URL before starting the app or running integration tests.");
+// ../../src/core/database/queryProxy.ts
+var POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
+function createDatabaseQueryProxy(pool) {
+  function resolveDatabase() {
+    return getActiveDatabaseConnection(pool);
   }
-  return new SQL({
-    url: config.url,
-    max: config.poolMax,
-    idleTimeout: config.idleTimeoutSeconds,
-    maxLifetime: config.maxLifetimeSeconds,
-    connectionTimeout: config.connectionTimeoutSeconds
+  function resolveDatabaseForProperty(property) {
+    if (typeof property === "string" && POOL_CONNECTION_METHODS.has(property)) {
+      return pool;
+    }
+    return resolveDatabase();
+  }
+  return new Proxy(function database() {}, {
+    apply(_target, _thisArg, args) {
+      return resolveDatabase()(...args);
+    },
+    get(_target, property) {
+      const connection = resolveDatabaseForProperty(property);
+      const value = connection[property];
+      return typeof value === "function" ? value.bind(connection) : value;
+    }
   });
 }
 
-// ../../src/db/connection/index.ts
-var connectionHolder = {
+// ../../src/core/database/defaultConnection.ts
+var defaultPool = {
   connection: null
 };
-function getDatabase() {
-  if (!connectionHolder.connection) {
-    connectionHolder.connection = createDatabaseConnection(databaseConfig);
-  }
-  return connectionHolder.connection;
-}
-var POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
-function resolveDatabase() {
-  return getActiveDatabaseConnection(getDatabase());
-}
-function resolveDatabaseForProperty(property) {
-  if (typeof property === "string" && POOL_CONNECTION_METHODS.has(property)) {
-    return getDatabase();
-  }
-  return resolveDatabase();
-}
-var db = new Proxy(function database() {}, {
-  apply(_target, _thisArg, args) {
-    return resolveDatabase()(...args);
-  },
-  get(_target, property) {
-    const connection = resolveDatabaseForProperty(property);
-    const value = connection[property];
-    return typeof value === "function" ? value.bind(connection) : value;
-  }
-});
-var connection_default = db;
-
-// ../../src/core/database/boundConnection.ts
-var boundConnectionHolder = {
+var defaultQuery = {
   connection: null
 };
-function bindDatabaseConnection(connection) {
-  boundConnectionHolder.connection = connection;
+function registerDefaultDatabasePool(connection) {
+  defaultPool.connection = connection;
+  defaultQuery.connection = createDatabaseQueryProxy(connection);
 }
-function getBoundDatabaseConnection() {
-  return boundConnectionHolder.connection;
+function getDefaultDatabaseQuery() {
+  if (!defaultQuery.connection) {
+    throw new Error("Default database query handle is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
+  }
+  return defaultQuery.connection;
 }
 
 // ../../src/core/database/repositoryConnection.ts
 function resolveRepositoryConnection() {
-  return getBoundDatabaseConnection() ?? connection_default;
+  return getBoundDatabaseConnection() ?? getDefaultDatabaseQuery();
 }
-var repositoryConnection = new Proxy({}, {
+var repositoryConnection = new Proxy(function repositoryConnection2() {}, {
+  apply(_target, _thisArg, args) {
+    return resolveRepositoryConnection()(...args);
+  },
   get(_target, property) {
     const connection = resolveRepositoryConnection();
     const value = connection[property];
@@ -1597,327 +1484,10 @@ class BaseRepository {
   }
 }
 var baseRepository_default = BaseRepository;
-// ../../src/core/database/connection.ts
-function createDatabaseConnection2(source) {
-  return {
-    async unsafe(query, params = []) {
-      return await source.unsafe(query, params);
-    }
-  };
-}
 // ../../src/core/database/model.ts
 var modelRepositories = new WeakMap;
 var modelGlobalScopes = new WeakMap;
 var modelBooted = new WeakSet;
-function resolveModelRepository(model) {
-  const repository = modelRepositories.get(model);
-  if (!repository) {
-    throw new Error(`${model.name}.repository() is not implemented.`);
-  }
-  return repository;
-}
-function modelStatics(model) {
-  return model;
-}
-function ensureBooted(model) {
-  if (modelBooted.has(model)) {
-    return;
-  }
-  modelBooted.add(model);
-  const boot = model.boot;
-  if (typeof boot === "function") {
-    boot.call(model);
-  }
-}
-function getGlobalScopes(model) {
-  return modelGlobalScopes.get(model) ?? [];
-}
-function hydrateValue(value, cast) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  switch (cast) {
-    case "date":
-    case "datetime":
-      return value instanceof Date ? value : new Date(String(value));
-    case "json":
-      return typeof value === "string" ? JSON.parse(value) : value;
-    case "bool":
-    case "boolean":
-      return value === true || value === 1 || value === "1" || value === "true";
-    default:
-      return value;
-  }
-}
-function dehydrateValue(value, cast) {
-  if (value === null || value === undefined) {
-    return value;
-  }
-  switch (cast) {
-    case "date":
-    case "datetime":
-      return value instanceof Date ? value : new Date(String(value));
-    case "json":
-      return typeof value === "string" ? value : JSON.stringify(value);
-    case "bool":
-    case "boolean":
-      return Boolean(value);
-    default:
-      return value;
-  }
-}
-function filterMassAssignable(fillable, guarded, input) {
-  const resolvedGuarded = guarded ?? true;
-  if (fillable && fillable.length > 0) {
-    const allowed = new Set(fillable);
-    return Object.fromEntries(Object.entries(input).filter(([key]) => allowed.has(key)));
-  }
-  if (resolvedGuarded === true || resolvedGuarded.includes("*")) {
-    return {};
-  }
-  const blocked = new Set(resolvedGuarded);
-  return Object.fromEntries(Object.entries(input).filter(([key]) => !blocked.has(key)));
-}
-function applyCasts(values, casts, direction) {
-  if (Object.keys(casts).length === 0) {
-    return values;
-  }
-  const result = { ...values };
-  const castFn = direction === "hydrate" ? hydrateValue : dehydrateValue;
-  for (const [key, cast] of Object.entries(casts)) {
-    if (key in result && cast) {
-      result[key] = castFn(result[key], cast);
-    }
-  }
-  return result;
-}
-function applyTimestampsOnCreate(columns, values, enabled) {
-  if (!enabled) {
-    return values;
-  }
-  const now = new Date;
-  const result = { ...values };
-  if (columns.includes("created_at")) {
-    result.created_at = now;
-  }
-  if (columns.includes("updated_at")) {
-    result.updated_at = now;
-  }
-  return result;
-}
-function applyTimestampsOnUpdate(columns, values, enabled) {
-  if (!enabled) {
-    return values;
-  }
-  const result = { ...values };
-  if (columns.includes("updated_at")) {
-    result.updated_at = new Date;
-  }
-  return result;
-}
-
-class Model {
-  attributes;
-  repository;
-  static $fillable;
-  static $guarded;
-  static $casts = {};
-  static $timestamps = true;
-  _exists;
-  constructor(attributes, repository, exists = true) {
-    this.attributes = attributes;
-    this.repository = repository;
-    this._exists = exists;
-  }
-  get $exists() {
-    return this._exists;
-  }
-  get(key) {
-    return this.attributes[key];
-  }
-  get id() {
-    return this.attributes[this.primaryKey()];
-  }
-  toObject() {
-    return { ...this.attributes };
-  }
-  primaryKey() {
-    throw new Error(`${this.constructor.name}.primaryKey() is not implemented.`);
-  }
-  static primaryKeyField() {
-    return resolveModelRepository(this).getTable().primaryKey;
-  }
-  static hydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
-    return applyCasts(attributes, casts, "hydrate");
-  }
-  static dehydrateAttributes(attributes) {
-    const casts = modelStatics(this).$casts ?? {};
-    return applyCasts(attributes, casts, "dehydrate");
-  }
-  static fromRecord(record, repository, exists = true) {
-    const statics = modelStatics(this);
-    const hydrated = statics.hydrateAttributes(record);
-    return new statics(hydrated, repository, exists);
-  }
-  static boot() {}
-  static addGlobalScope(_name, scope) {
-    ensureBooted(this);
-    const existing = modelGlobalScopes.get(this) ?? [];
-    modelGlobalScopes.set(this, [
-      ...existing,
-      scope
-    ]);
-  }
-  static repository() {
-    return resolveModelRepository(this);
-  }
-  static query() {
-    ensureBooted(this);
-    const repository = resolveModelRepository(this);
-    let query = repository.query();
-    for (const scope of getGlobalScopes(this)) {
-      query = scope(query);
-    }
-    return query;
-  }
-  static async create(attributes) {
-    const statics = modelStatics(this);
-    ensureBooted(this);
-    const repository = resolveModelRepository(this);
-    const table = repository.getTable();
-    const timestamps = statics.$timestamps ?? true;
-    const assignable = filterMassAssignable(statics.$fillable, statics.$guarded, attributes);
-    const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = statics.dehydrateAttributes(withTimestamps);
-    const record = await repository.create(payload);
-    return statics.fromRecord(record, repository, true);
-  }
-  static async find(id) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    const primaryKey = repository.getTable().primaryKey;
-    const record = await Model.query.call(this).where({ [primaryKey]: id }).first();
-    return record ? statics.fromRecord(record, repository, true) : null;
-  }
-  static async findOrFail(id, errorFactory) {
-    const model = await Model.find.call(this, id);
-    if (model) {
-      return model;
-    }
-    throw errorFactory?.(id) ?? new NotFoundError(`${this.name} ${String(id)} not found.`);
-  }
-  static async all(options = {}) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    let query = Model.query.call(this);
-    if (options.orderBy) {
-      query = query.orderBy(options.orderBy);
-    }
-    if (options.limit !== undefined) {
-      query = query.limit(options.limit);
-    }
-    const rows = await query.get();
-    return rows.map((row) => statics.fromRecord(row, repository, true));
-  }
-  static async firstWhere(where, options = {}) {
-    const statics = modelStatics(this);
-    const repository = resolveModelRepository(this);
-    let query = Model.query.call(this).where(where);
-    if (options.orderBy) {
-      query = query.orderBy(options.orderBy);
-    }
-    const record = await query.first();
-    return record ? statics.fromRecord(record, repository, true) : null;
-  }
-  async save() {
-    const ModelClass = modelStatics(this.constructor);
-    const timestamps = ModelClass.$timestamps ?? true;
-    const casts = ModelClass.$casts ?? {};
-    const table = this.repository.getTable();
-    if (this.$exists) {
-      const changes = applyTimestampsOnUpdate(table.columns, applyCasts(this.attributes, casts, "dehydrate"), timestamps);
-      const record2 = await this.repository.updateByIdOrThrow(this.id, changes);
-      this.attributes = ModelClass.hydrateAttributes(record2);
-      return this;
-    }
-    const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, this.attributes);
-    const withTimestamps = applyTimestampsOnCreate(table.columns, assignable, timestamps);
-    const payload = ModelClass.dehydrateAttributes(withTimestamps);
-    const record = await this.repository.create(payload);
-    this.attributes = ModelClass.hydrateAttributes(record);
-    this._exists = true;
-    return this;
-  }
-  async update(changes) {
-    const ModelClass = modelStatics(this.constructor);
-    const assignable = filterMassAssignable(ModelClass.$fillable, ModelClass.$guarded, changes);
-    Object.assign(this.attributes, assignable);
-    return await this.save();
-  }
-  async delete() {
-    if (resolveSoftDeleteColumn(this.repository.getTable())) {
-      return await this.repository.deleteById(this.id);
-    }
-    return await this.repository.forceDeleteById(this.id);
-  }
-  async forceDelete() {
-    return await this.repository.forceDeleteById(this.id);
-  }
-  async restore() {
-    const ModelClass = modelStatics(this.constructor);
-    const record = await this.repository.restoreById(this.id);
-    if (!record) {
-      return null;
-    }
-    this.attributes = ModelClass.hydrateAttributes(record);
-    return this;
-  }
-  async loadHasMany(as, relation, childRepository, options = {}) {
-    const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
-    const loaded = grouped.get(this.attributes[relation.localKey]) ?? [];
-    return Object.assign(this, { [as]: loaded });
-  }
-  async loadHasOne(as, relation, childRepository, options = {}) {
-    const loaded = await this.loadHasMany(as, relation, childRepository, { ...options, limit: 1 });
-    const value = loaded[as]?.[0];
-    return Object.assign(this, { [as]: value });
-  }
-  async loadBelongsTo(as, relation, parentRepository, options = {}) {
-    const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
-    const loaded = grouped.get(this.attributes[relation.foreignKey]);
-    return Object.assign(this, { [as]: loaded });
-  }
-  async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
-    const connection = this.repository.getConnection();
-    const parentId = this.attributes[relation.parentKey];
-    const pivotRows = await connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} = $1`, [parentId]);
-    if (pivotRows.length === 0) {
-      return Object.assign(this, { [as]: [] });
-    }
-    const relatedIds = [
-      ...new Set(pivotRows.map((row) => row[relation.relatedPivotKey]))
-    ];
-    const relatedRows = await relatedRepository.withConnection(connection).findAll({
-      ...options,
-      where: {
-        [relation.relatedKey]: relatedIds
-      }
-    });
-    const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
-    const loaded = grouped.get(parentId) ?? [];
-    return Object.assign(this, { [as]: loaded });
-  }
-  mergeAttributes(patch) {
-    Object.assign(this.attributes, patch);
-    return this;
-  }
-}
-function registerModelRepository(model, repository) {
-  modelRepositories.set(model, repository);
-  ensureBooted(model);
-  return model;
-}
 // ../../src/core/database/schema/columnDefinition.ts
 class ColumnDefinition {
   name;
@@ -2139,45 +1709,6 @@ class Blueprint {
     });
   }
 }
-// ../../src/core/database/schema/driver.ts
-function normalizeConnectionName(connection) {
-  const normalized = connection.trim().toLowerCase();
-  if (normalized === "pgsql" || normalized === "postgres" || normalized === "postgresql") {
-    return "pgsql";
-  }
-  if (normalized === "mysql" || normalized === "mariadb") {
-    return "mysql";
-  }
-  if (normalized === "sqlite") {
-    return "sqlite";
-  }
-  throw new Error(`Unsupported DB_CONNECTION: ${connection}`);
-}
-function resolveDriverFromUrl(url) {
-  const normalized = url.trim().toLowerCase();
-  if (normalized.startsWith("postgres://") || normalized.startsWith("postgresql://") || normalized.startsWith("postgres:")) {
-    return "pgsql";
-  }
-  if (normalized.startsWith("mysql://") || normalized.startsWith("mysql:")) {
-    return "mysql";
-  }
-  if (normalized.startsWith("sqlite:")) {
-    return "sqlite";
-  }
-  return null;
-}
-function resolveDatabaseDriver(options = {}) {
-  const connection = options.connection ?? process.env.DB_CONNECTION;
-  if (connection) {
-    return normalizeConnectionName(connection);
-  }
-  const url = options.url ?? process.env.DATABASE_URL ?? "";
-  const fromUrl = resolveDriverFromUrl(url);
-  if (fromUrl) {
-    return fromUrl;
-  }
-  return "pgsql";
-}
 // ../../src/core/database/schema/errors.ts
 class UnsupportedSchemaFeatureError extends Error {
   constructor(feature, driver) {
@@ -2516,48 +2047,70 @@ class SchemaBuilder {
   toSql() {
     return [...this.#statements];
   }
-  async execute(db2) {
+  async execute(db) {
     for (const statement of this.#statements) {
-      await db2.unsafe(statement);
+      await db.unsafe(statement);
     }
   }
 }
-
-class Schema {
-  static builder(driver) {
-    return new SchemaBuilder(driver ?? resolveDatabaseDriver());
-  }
-  static async run(db2, driver, callback) {
-    const schema = Schema.builder(driver);
-    await callback(schema);
-    await schema.execute(db2);
-  }
-}
-function createSchemaBuilder(db2, driver) {
-  const builder = Schema.builder(driver);
-  return Object.assign(builder, {
-    async commit() {
-      await builder.execute(db2);
-    }
-  });
-}
 // ../../src/core/database/table.ts
 function defineTable(definition) {
   return definition;
 }
-// ../../src/core/database/transaction.ts
-function supportsTransactions(connection) {
-  return typeof connection.begin === "function";
+// ../../src/config/database.ts
+function readInteger(name, fallback) {
+  const parsed = Number.parseInt(process.env[name] ?? String(fallback), 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
 }
-async function runInTransaction(operation) {
-  const pool = resolveRepositoryConnection();
-  if (!supportsTransactions(pool)) {
-    throw new Error("Active database connection does not support transactions. Bind a client with begin() via bindDatabaseConnection.");
+var databaseConfig = {
+  url: process.env.DATABASE_URL ?? "",
+  poolMax: readInteger("DB_POOL_MAX", 10),
+  idleTimeoutSeconds: readInteger("DB_POOL_IDLE_TIMEOUT", 30),
+  maxLifetimeSeconds: readInteger("DB_POOL_MAX_LIFETIME", 3600),
+  connectionTimeoutSeconds: readInteger("DB_CONNECTION_TIMEOUT", 10)
+};
+
+// ../../src/db/connection/createConnection.ts
+var {SQL } = globalThis.Bun;
+function createDatabaseConnection2(config) {
+  if (!config.url) {
+    throw new Error("DATABASE_URL is not configured. Set DATABASE_URL before starting the app or running integration tests.");
   }
-  return await pool.begin(async (transaction) => {
-    return await operation(createDatabaseConnection2(transaction));
+  return new SQL({
+    url: config.url,
+    max: config.poolMax,
+    idleTimeout: config.idleTimeoutSeconds,
+    maxLifetime: config.maxLifetimeSeconds,
+    connectionTimeout: config.connectionTimeoutSeconds
   });
 }
+
+// ../../src/db/connection/index.ts
+var connectionHolder = {
+  connection: null
+};
+function getDatabase() {
+  if (!connectionHolder.connection) {
+    connectionHolder.connection = createDatabaseConnection2(databaseConfig);
+    registerDefaultDatabasePool(connectionHolder.connection);
+  }
+  return connectionHolder.connection;
+}
+function getDb() {
+  getDatabase();
+  return getDefaultDatabaseQuery();
+}
+var db = new Proxy(function database() {}, {
+  apply(_target, _thisArg, args) {
+    return getDb()(...args);
+  },
+  get(_target, property) {
+    const connection = getDb();
+    const value = connection[property];
+    return typeof value === "function" ? value.bind(connection) : value;
+  }
+});
+
 // ../../src/modules/user/apiTokenTable.ts
 var apiTokenTable = defineTable({
   name: "api_token",
@@ -2690,9 +2243,6 @@ function revealMfaSecret(stored) {
 // ../../src/core/auth/authContext.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
 var authContext = new AsyncLocalStorage2;
-function runWithAuthUser(user, callback) {
-  return authContext.run(user, callback);
-}
 function currentAuthUser() {
   return authContext.getStore() ?? null;
 }
@@ -2700,9 +2250,6 @@ function currentAuthUser() {
 // ../../src/core/http/requestMetaContext.ts
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 var requestMetaContext = new AsyncLocalStorage3;
-function runWithRequestMeta(meta, callback) {
-  return requestMetaContext.run(meta, callback);
-}
 function currentRequestMeta() {
   return requestMetaContext.getStore() ?? {
     ipAddress: null,
@@ -2788,25 +2335,12 @@ function verifyTotp(secret, token, window = 1) {
 // ../../src/core/tenant/tenantContext.ts
 import { AsyncLocalStorage as AsyncLocalStorage4 } from "async_hooks";
 var tenantContext = new AsyncLocalStorage4;
-function runWithTenant(tenant, callback) {
-  return tenantContext.run(tenant, callback);
-}
 function currentTenant() {
   return tenantContext.getStore() ?? null;
 }
 function currentTenantId() {
   return currentTenant()?.id ?? 1;
 }
-function rateLimitMultiplierForPlan(plan) {
-  switch (plan) {
-    case "enterprise":
-      return 4;
-    case "pro":
-      return 2;
-    default:
-      return 1;
-  }
-}
 
 // ../../src/domain/abilities.ts
 var MEMBER_ABILITIES = [
@@ -3018,9 +2552,6 @@ function readRequestCookie(request, name) {
   }
   return null;
 }
-function readBunRequestCookie(request, name) {
-  return request.cookies.get(name) ?? readRequestCookie(request, name);
-}
 
 // ../../src/core/http/csrfToken.ts
 var CSRF_COOKIE = "workhub_csrf";