@getstrata/core 0.5.13 → 0.5.15

package/dist/entries/queue/queueMetrics.js

@@ -3,9 +3,6 @@
 var {RedisClient: RedisClient2 } = globalThis.Bun;
 
 // ../../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";
 
@@ -123,15 +120,9 @@ function getRequiredDependency(dependencies, key) {
   }
   return dependency;
 }
-function resolveService(dependencies, token) {
-  return dependencies.container.resolve(token);
-}
 
 // ../../src/bootstrap/applicationRegistry.ts
 var activeContext;
-function setActiveApplicationContext(context) {
-  activeContext = context;
-}
 function requireActiveApplicationContext() {
   if (!activeContext) {
     throw new Error("The application context has not been bootstrapped.");
@@ -141,24 +132,6 @@ function requireActiveApplicationContext() {
 function resolveApplicationCache() {
   return getRequiredDependency(requireActiveApplicationContext().dependencies, "cache");
 }
-function resolveApplicationQueue() {
-  return requireActiveApplicationContext().container.resolve(CORE_QUEUE_TOKEN);
-}
-function resolveApplicationAuth() {
-  return requireActiveApplicationContext().container.resolve(CORE_AUTH_TOKEN);
-}
-function resolveApplicationPolicyGate() {
-  return requireActiveApplicationContext().container.resolve(CORE_POLICY_GATE_TOKEN);
-}
-function resolveApplicationConfig() {
-  return requireActiveApplicationContext().config;
-}
-function resolveApplicationLogger() {
-  return appLogger;
-}
-function resolveApplicationDependencies() {
-  return requireActiveApplicationContext().dependencies;
-}
 
 // ../../src/core/jobs/dispatchWebhookJob.ts
 import { createHmac } from "crypto";
@@ -172,75 +145,77 @@ var appConfig = {
   apiPrefix: process.env.API_PREFIX ?? "/api/v1"
 };
 
-// ../../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.");
-  }
-  return new SQL({
-    url: config.url,
-    max: config.poolMax,
-    idleTimeout: config.idleTimeoutSeconds,
-    maxLifetime: config.maxLifetimeSeconds,
-    connectionTimeout: config.connectionTimeoutSeconds
+// ../../src/core/database/queryProxy.ts
+var POOL_CONNECTION_METHODS = new Set(["begin", "close", "connect"]);
+function createDatabaseQueryProxy(pool) {
+  function resolveDatabase() {
+    return getActiveDatabaseConnection(pool);
+  }
+  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());
+var defaultQuery = {
+  connection: null
+};
+function registerDefaultDatabasePool(connection) {
+  defaultPool.connection = connection;
+  defaultQuery.connection = createDatabaseQueryProxy(connection);
 }
-function resolveDatabaseForProperty(property) {
-  if (typeof property === "string" && POOL_CONNECTION_METHODS.has(property)) {
-    return getDatabase();
+function getDefaultDatabaseQuery() {
+  if (!defaultQuery.connection) {
+    throw new Error("Default database query handle is not registered. Call registerDefaultDatabasePool() during app bootstrap.");
   }
-  return resolveDatabase();
+  return defaultQuery.connection;
 }
-var db = new Proxy(function database() {}, {
+
+// ../../src/core/database/repositoryConnection.ts
+function resolveRepositoryConnection() {
+  return getBoundDatabaseConnection() ?? getDefaultDatabaseQuery();
+}
+var repositoryConnection = new Proxy(function repositoryConnection2() {}, {
   apply(_target, _thisArg, args) {
-    return resolveDatabase()(...args);
+    return resolveRepositoryConnection()(...args);
   },
   get(_target, property) {
-    const connection = resolveDatabaseForProperty(property);
+    const connection = resolveRepositoryConnection();
     const value = connection[property];
     return typeof value === "function" ? value.bind(connection) : value;
   }
 });
-var connection_default = db;
 
 // ../../src/core/queue/index.ts
 class Job {
@@ -249,56 +224,8 @@ class Job {
   priority;
 }
 
-class SyncQueue {
-  async dispatch(job, payload) {
-    await job.handle(payload);
-  }
-}
-
-class AsyncQueue {
-  async dispatch(job, payload) {
-    setTimeout(() => {
-      job.handle(payload).catch((error) => {
-        console.error("[AsyncQueue] Job failed:", error);
-      });
-    }, 0);
-  }
-}
-function createQueue(driver) {
-  return driver === "async" ? new AsyncQueue : new SyncQueue;
-}
-
-// ../../src/core/security/safeFetch.ts
-var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
-async function safeFetch(input, init = {}, options = {}) {
-  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
-  const maxRedirects = options.maxRedirects ?? 0;
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    let currentUrl = input;
-    let redirectCount = 0;
-    while (true) {
-      const response = await fetch(currentUrl, {
-        ...init,
-        signal: controller.signal,
-        redirect: "manual"
-      });
-      if (response.status >= 300 && response.status < 400) {
-        const location = response.headers.get("location");
-        if (!location || redirectCount >= maxRedirects) {
-          return response;
-        }
-        currentUrl = new URL(location, currentUrl).toString();
-        redirectCount += 1;
-        continue;
-      }
-      return response;
-    }
-  } finally {
-    clearTimeout(timeout);
-  }
-}
+// ../../src/core/security/safeUrl.ts
+import { lookup as dnsLookupImpl } from "dns/promises";
 
 // ../../src/core/errors/http.ts
 class HttpError extends Error {
@@ -367,6 +294,7 @@ class PreconditionFailedError extends HttpError {
 }
 
 // ../../src/core/security/safeUrl.ts
+var dnsLookup = dnsLookupImpl;
 var BLOCKED_HOSTNAMES = new Set([
   "localhost",
   "127.0.0.1",
@@ -438,16 +366,68 @@ function assertSafeOutboundUrl(rawUrl, options = {}) {
   }
   return parsed;
 }
+function isBlockedIpAddress(address) {
+  return isBlockedHostname(address.trim().toLowerCase());
+}
+async function assertSafeOutboundUrlResolved(rawUrl, options = {}) {
+  const parsed = assertSafeOutboundUrl(rawUrl, options);
+  if (options.resolveDns === false) {
+    return parsed;
+  }
+  const hostname = parsed.hostname.trim().toLowerCase();
+  const results = await dnsLookup(hostname, { all: true, verbatim: true });
+  if (results.some((result) => isBlockedIpAddress(result.address))) {
+    throw new BadRequestError("Webhook URL targets a blocked host.");
+  }
+  return parsed;
+}
+function setDnsLookupForTests(lookupFn) {
+  dnsLookup = lookupFn;
+}
+function resetDnsLookupForTests() {
+  dnsLookup = dnsLookupImpl;
+}
+
+// ../../src/core/security/safeFetch.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
+async function safeFetch(input, init = {}, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+  const maxRedirects = options.maxRedirects ?? 0;
+  const resolveDns = options.resolveDns ?? appConfig.env === "production";
+  const urlOptions = { allowHttp: options.allowHttp, resolveDns };
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    let currentUrl = (await assertSafeOutboundUrlResolved(input, urlOptions)).toString();
+    let redirectCount = 0;
+    while (true) {
+      const response = await fetch(currentUrl, {
+        ...init,
+        signal: controller.signal,
+        redirect: "manual"
+      });
+      if (response.status >= 300 && response.status < 400) {
+        const location = response.headers.get("location");
+        if (!location || redirectCount >= maxRedirects) {
+          return response;
+        }
+        currentUrl = (await assertSafeOutboundUrlResolved(new URL(location, currentUrl).toString(), urlOptions)).toString();
+        redirectCount += 1;
+        continue;
+      }
+      return response;
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
 
 // ../../src/core/jobs/dispatchWebhookJob.ts
 class DispatchWebhookJob extends Job {
-  constructor() {
-    super();
-  }
   maxAttempts = 3;
   backoffMs = 2000;
   async handle(payload) {
-    const rows = await connection_default`
+    const rows = await repositoryConnection`
       SELECT id, url, secret
       FROM webhook
       WHERE id = ${payload.webhookId} AND active = TRUE
@@ -470,14 +450,14 @@ class DispatchWebhookJob extends Job {
           "x-workhub-signature": signature
         },
         body
-      });
+      }, { allowHttp: appConfig.env !== "production" });
       responseStatus = response.status;
       if (!response.ok) {
         throw new Error(`Webhook delivery failed with status ${response.status}.`);
       }
     } catch (error) {
       errorMessage = error instanceof Error ? error.message : String(error);
-      await connection_default`
+      await repositoryConnection`
         INSERT INTO webhook_delivery (webhook_id, event, payload, response_status, error)
         VALUES (
           ${webhook.id},
@@ -489,7 +469,7 @@ class DispatchWebhookJob extends Job {
       `;
       throw error instanceof Error ? error : new Error(errorMessage);
     }
-    await connection_default`
+    await repositoryConnection`
       INSERT INTO webhook_delivery (webhook_id, event, payload, response_status)
       VALUES (
         ${webhook.id},
@@ -748,14 +728,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);
@@ -1058,30 +1030,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) {
@@ -1097,15 +1045,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) {
@@ -1121,45 +1060,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) {
@@ -1178,15 +1078,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) {
@@ -1203,29 +1094,6 @@ function indexMorphToRelation(children, parentsByType, relation) {
   return result;
 }
 
-// ../../src/core/database/boundConnection.ts
-var boundConnectionHolder = {
-  connection: null
-};
-function bindDatabaseConnection(connection) {
-  boundConnectionHolder.connection = connection;
-}
-function getBoundDatabaseConnection() {
-  return boundConnectionHolder.connection;
-}
-
-// ../../src/core/database/repositoryConnection.ts
-function resolveRepositoryConnection() {
-  return getBoundDatabaseConnection() ?? connection_default;
-}
-var repositoryConnection = new Proxy({}, {
-  get(_target, property) {
-    const connection = resolveRepositoryConnection();
-    const value = connection[property];
-    return typeof value === "function" ? value.bind(connection) : value;
-  }
-});
-
 // ../../src/core/database/whereBuilder.ts
 class WhereBuilder {
   nodes = [];
@@ -1781,327 +1649,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;
@@ -2323,45 +1874,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) {
@@ -2700,48 +2212,16 @@ 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";
-}
-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.");
-  }
-  return await pool.begin(async (transaction) => {
-    return await operation(createDatabaseConnection2(transaction));
-  });
-}
 // ../../src/core/queue/failedJobTable.ts
 var failedJobTable = defineTable({
   name: "failed_job",