@spfn/core 0.3.0-beta.32 → 0.3.0-beta.34

package/dist/db/index.js

@@ -5,11 +5,11 @@ import net from 'net';
 import postgres from 'postgres';
 import { QueryError, ConnectionError, DeadlockError, TransactionError, ConstraintViolationError, DuplicateEntryError, SerializableError } from '@spfn/core/errors';
 import { parseNumber, parseBoolean } from '@spfn/core/env';
+import { sql, count as count$1, lt, gt, and, desc, asc, getTableName, eq, isTable, getColumns, is, View } from 'drizzle-orm';
 import { existsSync, readdirSync, readFileSync, statSync, realpathSync, lstatSync } from 'fs';
 import { join, relative } from 'path';
 import mm from 'micromatch';
-import { sql, count as count$1, lt, gt, and, desc, asc, eq } from 'drizzle-orm';
-import { bigserial, timestamp, bigint, uuid as uuid$1, text, jsonb, pgSchema } from 'drizzle-orm/pg-core';
+import { bigserial, bigint, timestamp, uuid as uuid$1, text, jsonb, pgSchema } from 'drizzle-orm/pg-core';
 import { createHash, randomUUID } from 'crypto';
 import { AsyncLocalStorage } from 'async_hooks';
 import { createMiddleware } from 'hono/factory';
@@ -397,9 +397,95 @@ function buildMonitoringConfig(options) {
     logQueries: options?.logQueries ?? parseEnvBoolean("DB_MONITORING_LOG_QUERIES", false)
   };
 }
+var TABLE_SCHEMA = Symbol.for("drizzle:Schema");
+var tenantColumnConfigs = /* @__PURE__ */ new WeakSet();
+var tenantColumnByTable = /* @__PURE__ */ new WeakMap();
+var tenantTables = /* @__PURE__ */ new Map();
+function registerTenantColumn(table, column) {
+  const name = getTableName(table);
+  if (tenantColumnByTable.has(table)) {
+    throw new Error(`Table "${name}" declares more than one tenantKey() column`);
+  }
+  const schema = table[TABLE_SCHEMA];
+  tenantColumnByTable.set(table, column);
+  tenantColumnConfigs.add(configOf(column));
+  tenantTables.set(`${schema ?? ""}.${name}`, { schema, name, columnName: column.name });
+}
+function findTenantColumn(table) {
+  if (!isTable(table)) {
+    return void 0;
+  }
+  const entry = Object.entries(getColumns(table)).find(([, column]) => tenantColumnConfigs.has(configOf(column)));
+  return entry ? { key: entry[0], column: entry[1] } : void 0;
+}
+function listTenantTables() {
+  return [...tenantTables.values()];
+}
+function configOf(column) {
+  return column.config;
+}
+
+// src/db/tenant/query-warning.ts
+var WARNING_ENVIRONMENTS = /* @__PURE__ */ new Set(["local", "development"]);
+function createDevelopmentQueryLogger(nodeEnv, warn) {
+  return nodeEnv && WARNING_ENVIRONMENTS.has(nodeEnv) ? createTenantQueryLogger({ warn }) : void 0;
+}
+function createTenantQueryLogger(options) {
+  const warned = /* @__PURE__ */ new Set();
+  const tables = options.tables ?? listTenantTables;
+  function warnIfUnscoped(query) {
+    if (warned.has(query)) {
+      return;
+    }
+    const unscoped = findUnscopedTenantTables(query, tables());
+    if (unscoped.length > 0) {
+      warned.add(query);
+      options.warn("Query on a tenant-aware table without a tenant condition", { tables: unscoped, sql: query });
+    }
+  }
+  return {
+    logQuery(query) {
+      try {
+        warnIfUnscoped(query);
+      } catch {
+      }
+    }
+  };
+}
+function findUnscopedTenantTables(sql5, tables) {
+  if (/^\s*insert\b/i.test(sql5)) {
+    return [];
+  }
+  return tables.flatMap(
+    (table) => referencesOf(sql5, table).filter((reference) => !hasTenantCondition(sql5, reference, table.columnName)).map((reference) => reference.label)
+  );
+}
+function referencesOf(sql5, table) {
+  const name = `"${escapeRegExp(table.name)}"`;
+  const qualifier = table.schema ? `"${escapeRegExp(table.schema)}"\\.${name}` : `(?<![".])${name}`;
+  const source = table.schema ? qualifier : `${qualifier}(?!\\.)`;
+  const pattern = new RegExp(`\\b(?:from|join|update)\\s+${source}(?:\\s+(?:as\\s+)?"([^"]+)")?`, "gi");
+  const references = /* @__PURE__ */ new Map();
+  for (const match of sql5.matchAll(pattern)) {
+    const alias = match[1];
+    references.set(alias ?? table.name, {
+      label: alias ?? table.name,
+      qualifier: alias ? `"${escapeRegExp(alias)}"` : qualifier
+    });
+  }
+  return [...references.values()];
+}
+function hasTenantCondition(sql5, reference, columnName) {
+  const condition = new RegExp(`${reference.qualifier}\\."${escapeRegExp(columnName)}"\\s*(?:=|in\\s*\\()`, "i");
+  return condition.test(sql5);
+}
+function escapeRegExp(text2) {
+  return text2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 
 // src/db/manager/factory.ts
 var dbLogger2 = logger.child("@spfn/core:database");
+var tenantLogger = logger.child("@spfn/core:tenant");
 function hasDatabaseConfig() {
   return env.DATABASE_URL !== void 0 || env.DATABASE_WRITE_URL !== void 0 || env.DATABASE_READ_URL !== void 0;
 }
@@ -428,6 +514,12 @@ function detectDatabasePattern() {
   }
   return { type: "none" };
 }
+function createDrizzle(client) {
+  const queryLogger = createDevelopmentQueryLogger(env.NODE_ENV, (message, warning) => {
+    tenantLogger.warn(message, { tables: warning.tables, sql: warning.sql });
+  });
+  return queryLogger ? drizzle({ client, logger: queryLogger }) : drizzle({ client });
+}
 async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig) {
   let writeClient;
   let readClient;
@@ -442,8 +534,8 @@ async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig
   try {
     readClient = await createDatabaseConnection(readUrl, readPoolConfig, retryConfig);
     return {
-      write: drizzle({ client: writeClient }),
-      read: drizzle({ client: readClient }),
+      write: createDrizzle(writeClient),
+      read: createDrizzle(readClient),
       writeClient,
       readClient
     };
@@ -459,8 +551,8 @@ async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig
       }
     );
     return {
-      write: drizzle({ client: writeClient }),
-      read: drizzle({ client: writeClient }),
+      write: createDrizzle(writeClient),
+      read: createDrizzle(writeClient),
       writeClient,
       readClient: writeClient
     };
@@ -468,7 +560,7 @@ async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig
 }
 async function createSingleClient(url, poolConfig, retryConfig) {
   const client = await createDatabaseConnection(url, poolConfig, retryConfig);
-  const db = drizzle({ client });
+  const db = createDrizzle(client);
   return {
     write: db,
     read: db,
@@ -1252,7 +1344,7 @@ function walkDirectory(dir, maxDepth, ancestors = /* @__PURE__ */ new Set()) {
   if (maxDepth < 1 || !safeStat(dir)?.isDirectory()) return walk;
   const realDir = realpathSafe(dir);
   if (ancestors.has(realDir)) return walk;
-  const chain = new Set(ancestors).add(realDir);
+  const chain2 = new Set(ancestors).add(realDir);
   for (const entry of safeReaddir(dir)) {
     const path = join(dir, entry);
     const stat = safeStat(path);
@@ -1261,7 +1353,7 @@ function walkDirectory(dir, maxDepth, ancestors = /* @__PURE__ */ new Set()) {
     } else if (stat?.isDirectory() && !SKIPPED_DIRECTORIES.test(entry)) {
       walk.directories.push(path);
       const isLink = isSymlink(path);
-      const child = walkDirectory(path, isLink ? Math.min(maxDepth - 1, 1) : maxDepth - 1, chain);
+      const child = walkDirectory(path, isLink ? Math.min(maxDepth - 1, 1) : maxDepth - 1, chain2);
       for (const file of child.files) walk.files.push(file);
       for (const sub of child.directories) walk.directories.push(sub);
     }
@@ -1481,6 +1573,17 @@ function generateDrizzleConfigFile(options = {}) {
 function id() {
   return bigserial("id", { mode: "number" }).primaryKey();
 }
+function tenantKey(name = "tenant_id") {
+  const builder = bigint(name, { mode: "number" }).notNull();
+  const buildable = builder;
+  const build = buildable.build;
+  buildable.build = function(table) {
+    const column = build.call(this, table);
+    registerTenantColumn(table, column);
+    return column;
+  };
+  return builder;
+}
 function timestamps() {
   return {
     createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
@@ -2168,6 +2271,32 @@ function buildWhereFromObject(table, where) {
   );
   return conditions.length === 1 ? conditions[0] : and(...conditions);
 }
+function buildWhereClause(table, where) {
+  if (isSQLWrapper(where)) {
+    return where;
+  }
+  return where ? buildWhereFromObject(table, where) : void 0;
+}
+async function countRows(db, table, where, options) {
+  const cap = options?.cap;
+  if (cap === void 0) {
+    const [result2] = await db.select({ count: count$1() }).from(table).where(where);
+    return Number(result2?.count ?? 0);
+  }
+  assertCountCap(cap);
+  const capped = db.select({ one: sql`1`.as("one") }).from(table).where(where).limit(cap + 1).as("capped");
+  const [result] = await db.select({ count: count$1() }).from(capped);
+  return Number(result?.count ?? 0);
+}
+function assertCountCap(cap) {
+  if (!Number.isSafeInteger(cap) || cap <= 0) {
+    throw new RangeError(`count cap must be a positive safe integer, received ${String(cap)}`);
+  }
+}
+function clampRowLimit(requested) {
+  const maxRows = env.DB_MAX_ROWS;
+  return maxRows > 0 ? Math.min(requested ?? maxRows, maxRows) : requested;
+}
 
 // src/db/helpers.ts
 async function findOne(table, where) {
@@ -2300,6 +2429,8 @@ async function count(table, where) {
   const [result] = await query;
   return Number(result?.count ?? 0);
 }
+
+// src/db/repository-core.ts
 var RepositoryError = class extends Error {
   constructor(message, repository, method, table, originalError) {
     super(message);
@@ -2313,7 +2444,7 @@ var RepositoryError = class extends Error {
     }
   }
 };
-var BaseRepository = class {
+var RepositoryCore = class {
   /**
    * Write database instance
    *
@@ -2405,6 +2536,10 @@ var BaseRepository = class {
       );
     }
   }
+};
+
+// src/db/repository.ts
+var BaseRepository = class extends RepositoryCore {
   // ============================================================================
   // CRUD Methods
   // ============================================================================
@@ -2460,9 +2595,7 @@ var BaseRepository = class {
       const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
       query = query.orderBy(...orderByArray);
     }
-    const maxRows = env.DB_MAX_ROWS;
-    const requestedLimit = options?.limit && options.limit > 0 ? options.limit : void 0;
-    const effectiveLimit = maxRows > 0 ? Math.min(requestedLimit ?? maxRows, maxRows) : requestedLimit;
+    const effectiveLimit = clampRowLimit(options?.limit && options.limit > 0 ? options.limit : void 0);
     if (effectiveLimit) {
       query = query.limit(effectiveLimit);
     }
@@ -2492,8 +2625,7 @@ var BaseRepository = class {
    */
   async _findManyKeyset(table, options) {
     const { cursorColumn, after, order = "asc", where } = options;
-    const maxRows = env.DB_MAX_ROWS;
-    const limit = maxRows > 0 ? Math.min(options.limit, maxRows) : options.limit;
+    const limit = clampRowLimit(options.limit);
     const baseWhere = where ? isSQLWrapper(where) ? where : buildWhereFromObject(table, where) : void 0;
     const cursorPredicate = after !== void 0 ? order === "desc" ? lt(cursorColumn, after) : gt(cursorColumn, after) : void 0;
     const whereClause = baseWhere && cursorPredicate ? and(baseWhere, cursorPredicate) : cursorPredicate ?? baseWhere;
@@ -2666,27 +2798,270 @@ var BaseRepository = class {
    *
    * @param table - Drizzle table schema
    * @param where - Optional object or SQL condition
-   * @returns Number of records
+   * @param options - `cap` stops counting past that many rows
+   * @returns Number of records; with `cap`, at most `cap + 1`, which means "more than cap"
    *
    * @example
    * ```typescript
    * const total = await this._count(users);
    * const activeUsers = await this._count(users, { active: true });
+   *
+   * // A list label: 1001 reads as "1,000+"
+   * const shown = await this._count(users, undefined, { cap: 1000 });
    * ```
    */
-  async _count(table, where) {
-    let query = this.readDb.select({ count: count$1() }).from(table);
-    if (where) {
-      const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-      if (whereClause) {
-        query = query.where(whereClause);
+  async _count(table, where, options) {
+    return countRows(this.readDb, table, buildWhereClause(table, where), options);
+  }
+};
+function assertTenantId(tenantId) {
+  if (typeof tenantId !== "number" || !Number.isSafeInteger(tenantId) || tenantId <= 0) {
+    throw new TypeError(`Tenant id must be a positive safe integer, received ${String(tenantId)}`);
+  }
+}
+function requireTenantColumn(table) {
+  const ref = findTenantColumn(table);
+  if (!ref) {
+    throw new Error(
+      `Table "${getTableName(table)}" has no tenantKey() column; TenantRepository methods take tenant-aware tables only`
+    );
+  }
+  return ref;
+}
+function tenantCondition(table, tenantId) {
+  return eq(requireTenantColumn(table).column, tenantId);
+}
+function optionalTenantCondition(table, tenantId) {
+  const ref = findTenantColumn(table);
+  return ref ? eq(ref.column, tenantId) : void 0;
+}
+function withCondition(condition, extra) {
+  if (!extra) {
+    return condition;
+  }
+  if (typeof condition === "function") {
+    return (...args) => and(condition(...args), extra);
+  }
+  return condition ? and(condition, extra) : extra;
+}
+var REFUSED_SELECT_MEMBERS = /* @__PURE__ */ new Set([
+  "rightJoin",
+  "fullJoin",
+  "crossJoin",
+  "leftJoinLateral",
+  "innerJoinLateral",
+  "crossJoinLateral",
+  "union",
+  "unionAll",
+  "intersect",
+  "intersectAll",
+  "except",
+  "exceptAll",
+  // The standalone union(a, b) / intersect / except functions from
+  // drizzle-orm/pg-core call this on the left query instead of the methods above.
+  "addSetOperators",
+  // The factories behind the join and set operator methods. TypeScript marks
+  // them private, but at runtime they are reachable and return drizzle's raw
+  // closures, which would add a join or a query unscoped.
+  "createJoin",
+  "createSetOperator"
+]);
+var SCOPED_JOINS = /* @__PURE__ */ new Set(["innerJoin", "leftJoin"]);
+function scopeSelectBuilder(builder, tenantId) {
+  return new Proxy(builder, {
+    get(target, prop, receiver) {
+      if (prop !== "from") {
+        return Reflect.get(target, prop, receiver);
       }
+      return (source) => scopeSelectQuery(target.from(source), source, tenantId);
+    }
+  });
+}
+function scopeSelectQuery(query, fromTable, tenantId) {
+  const fromCondition = tenantCondition(fromTable, tenantId);
+  query.where(fromCondition);
+  const proxy = new Proxy(query, {
+    get: (target, prop) => scopedMember(target, prop, { proxy, fromCondition, tenantId })
+  });
+  return proxy;
+}
+function scopedMember(target, prop, state) {
+  if (typeof prop === "string" && REFUSED_SELECT_MEMBERS.has(prop)) {
+    return () => {
+      throw new Error(`${prop}() is not supported on a TenantRepository _select; write this query on this.readDb`);
+    };
+  }
+  if (prop === "where") {
+    return (condition) => chain(target.where(withCondition(condition, state.fromCondition)), target, state);
+  }
+  if (typeof prop === "string" && SCOPED_JOINS.has(prop)) {
+    return (table, on) => {
+      assertNotView(table);
+      return chain(target[prop](table, withCondition(on, optionalTenantCondition(table, state.tenantId))), target, state);
+    };
+  }
+  return passThrough(target, prop, state);
+}
+function assertNotView(source) {
+  if (is(source, View)) {
+    throw new Error(
+      "A view cannot be joined on a TenantRepository _select; join the underlying table, or write this query on this.readDb"
+    );
+  }
+}
+function chain(result, target, state) {
+  return result === target ? state.proxy : result;
+}
+function passThrough(target, prop, state) {
+  const value = Reflect.get(target, prop, target);
+  if (typeof value !== "function") {
+    return value;
+  }
+  return (...args) => chain(value.apply(target, args), target, state);
+}
+
+// src/db/tenant/tenant-repository.ts
+var TenantRepository = class extends RepositoryCore {
+  // ============================================================================
+  // Reads
+  // ============================================================================
+  /** One row of the tenant matching `where`, or null. */
+  async _findOne(tenantId, table, where) {
+    const condition = this.requiredWhere(tenantId, table, where, "findOne");
+    const rows = await this.readDb.select().from(table).where(condition).limit(1);
+    return rows[0] ?? null;
+  }
+  /** Rows of the tenant, with the same options and DB_MAX_ROWS ceiling as BaseRepository. */
+  async _findMany(tenantId, table, options) {
+    let query = this.readDb.select().from(table).where(this.tenantWhere(tenantId, table, options?.where));
+    if (options?.orderBy) {
+      query = query.orderBy(...Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy]);
+    }
+    const limit = clampRowLimit(options?.limit && options.limit > 0 ? options.limit : void 0);
+    if (limit) {
+      query = query.limit(limit);
+    }
+    if (options?.offset) {
+      query = query.offset(options.offset);
+    }
+    return query;
+  }
+  /**
+   * Keyset (cursor) page of the tenant's rows. Index the table on
+   * (tenant column, cursor column) so a page reads only its own rows.
+   */
+  async _findManyKeyset(tenantId, table, options) {
+    const { cursorColumn, after, order = "asc" } = options;
+    const cursor = after === void 0 ? void 0 : order === "desc" ? lt(cursorColumn, after) : gt(cursorColumn, after);
+    const query = this.readDb.select().from(table).where(and(this.tenantWhere(tenantId, table, options.where), cursor)).orderBy(order === "desc" ? desc(cursorColumn) : asc(cursorColumn)).limit(clampRowLimit(options.limit));
+    return query;
+  }
+  /** Number of the tenant's rows; with `cap`, at most `cap + 1` ("more than cap"). */
+  async _count(tenantId, table, where, options) {
+    const condition = this.tenantWhere(tenantId, table, where);
+    return countRows(this.readDb, table, condition, options);
+  }
+  _select(tenantId, fields) {
+    assertTenantId(tenantId);
+    return scopeSelectBuilder(fields ? this.readDb.select(fields) : this.readDb.select(), tenantId);
+  }
+  // ============================================================================
+  // Writes
+  // ============================================================================
+  /** Insert one row for the tenant; a different tenant value in `data` throws. */
+  async _create(tenantId, table, data) {
+    const values = this.withTenantValue(tenantId, table, data);
+    const rows = await this.db.insert(table).values(values).returning();
+    return rows[0];
+  }
+  /** Insert rows for the tenant; every row is checked before any is written. */
+  async _createMany(tenantId, table, data) {
+    const values = data.map((row) => this.withTenantValue(tenantId, table, row));
+    const rows = await this.db.insert(table).values(values).returning();
+    return rows;
+  }
+  /**
+   * Insert, or update on conflict. The conflict target must include the
+   * tenant column: on `id` alone, an insert could collide with another
+   * tenant's row and update it.
+   */
+  async _upsert(tenantId, table, data, options) {
+    const values = this.withTenantValue(tenantId, table, data);
+    this.assertTargetHasTenant(table, options.target);
+    this.assertTenantUnchanged(table, options.set);
+    const rows = await this.db.insert(table).values(values).onConflictDoUpdate({ target: options.target, set: options.set || values }).returning();
+    return rows[0];
+  }
+  /** Update the tenant's rows matching `where`; returns the first, or null. */
+  async _updateOne(tenantId, table, where, data) {
+    const rows = await this.updateRows(tenantId, table, where, data, "updateOne");
+    return rows[0] ?? null;
+  }
+  /** Update the tenant's rows matching `where`. */
+  async _updateMany(tenantId, table, where, data) {
+    return this.updateRows(tenantId, table, where, data, "updateMany");
+  }
+  /** Delete the tenant's rows matching `where`; returns the first, or null. */
+  async _deleteOne(tenantId, table, where) {
+    const rows = await this.deleteRows(tenantId, table, where, "deleteOne");
+    return rows[0] ?? null;
+  }
+  /** Delete the tenant's rows matching `where`. */
+  async _deleteMany(tenantId, table, where) {
+    return this.deleteRows(tenantId, table, where, "deleteMany");
+  }
+  // ============================================================================
+  // Internals — private, so a subclass cannot reach an unscoped path through them
+  // ============================================================================
+  async updateRows(tenantId, table, where, data, method) {
+    const condition = this.requiredWhere(tenantId, table, where, method);
+    this.assertTenantUnchanged(table, data);
+    const rows = await this.db.update(table).set(data).where(condition).returning();
+    return rows;
+  }
+  async deleteRows(tenantId, table, where, method) {
+    const condition = this.requiredWhere(tenantId, table, where, method);
+    const rows = await this.db.delete(table).where(condition).returning();
+    return rows;
+  }
+  /** `tenant condition AND where`, after checking the tenant id and the table. */
+  tenantWhere(tenantId, table, where) {
+    assertTenantId(tenantId);
+    return and(tenantCondition(table, tenantId), buildWhereClause(table, where));
+  }
+  /** As tenantWhere, and `where` itself must filter on something besides the tenant. */
+  requiredWhere(tenantId, table, where, method) {
+    assertTenantId(tenantId);
+    const tenant = tenantCondition(table, tenantId);
+    const filter = buildWhereClause(table, where);
+    if (!filter) {
+      throw new Error(`${method} requires at least one where condition`);
+    }
+    return and(tenant, filter);
+  }
+  withTenantValue(tenantId, table, data) {
+    assertTenantId(tenantId);
+    const { key } = requireTenantColumn(table);
+    const given = data[key];
+    if (given !== void 0 && given !== tenantId) {
+      throw new Error(`${key} ${String(given)} does not match the tenant ${tenantId}`);
+    }
+    return { ...data, [key]: tenantId };
+  }
+  assertTenantUnchanged(table, data) {
+    const { key } = requireTenantColumn(table);
+    if (data && data[key] !== void 0) {
+      throw new Error(`${key} cannot be changed through TenantRepository`);
+    }
+  }
+  assertTargetHasTenant(table, target) {
+    const { column } = requireTenantColumn(table);
+    if (!target.some((targetColumn) => targetColumn.name === column.name)) {
+      throw new Error(`upsert target must include the tenant column "${column.name}"`);
     }
-    const [result] = await query;
-    return Number(result?.count ?? 0);
   }
 };
 
-export { BaseRepository, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, RUN_MIGRATIONS_HINT, RepositoryError, Transactional, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, onAfterRollback, onBeforeCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, renderDrizzleConfig, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
+export { BaseRepository, PROJECT_MIGRATIONS_TABLE, PROJECT_TARGET_NAME, RUN_MIGRATIONS_HINT, RepositoryError, TenantRepository, Transactional, auditFields, checkConnection, closeDatabase, collectMigrationStatus, count, countPendingMigrations, create, createDatabaseConnection, createDatabaseFromEnv, createMany, createSchema, deleteMany, deleteOne, detectDialect, discoverFunctionMigrations, enumText, filterPendingEntries, findMany, findOne, forceReconnectDatabase, foreignKey, formatPendingMigrations, fromPostgresError, functionMigrationsTable, generateDrizzleConfigFile, getDatabase, getDatabaseInfo, getDrizzleConfig, getSchemaInfo, getTransaction, getTransactionContext, hasMigrationTargets, id, initDatabase, isConnectionLevelError, migrationTargets, onAfterCommit, onAfterRollback, onBeforeCommit, optionalForeignKey, packageNameToSchema, pendingMigrationTargets, pendingMigrationsSummary, projectMigrationsDir, publishingFields, readMigrationEntries, renderDrizzleConfig, reportDatabaseError, resetConnectionErrorCounter, runInTransaction, runWithTransaction, setDatabase, setDatabaseProvider, softDelete, tenantKey, timestamps, typedJsonb, updateMany, updateOne, upsert, utcTimestamp, uuid, verificationTimestamp };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map