bun-query-builder 0.1.62 → 0.2.0

package/dist/config.d.ts

@@ -8,6 +8,19 @@ import type { QueryBuilderConfig, SupportedDialect } from './types';
  * same behavior; only DDL (see `SingleStoreDriver`) diverges.
  */
 export declare function isMysqlLike(dialect?: SupportedDialect): boolean;
+/**
+ * The dialect a command should operate on.
+ *
+ * `explicit` is what the user asked for on the command line — only honoured
+ * when they actually said something. Every CLI command used to declare
+ * `--dialect` with `{ default: 'postgres' }` and pass the result straight
+ * through, so the "default" arrived as an explicit choice and beat the
+ * project's own configuration: a SQLite app running `qb migrate` generated
+ * Postgres DDL, and `db:wipe` looked for `pg_tables`, unless every single
+ * invocation repeated `--dialect sqlite`. The fallbacks the actions already
+ * carried were unreachable.
+ */
+export declare function resolveDialect(explicit?: string | null): SupportedDialect;
 /**
  * Get the placeholder format for the current dialect.
  * PostgreSQL uses $1, $2, $3... while MySQL and SQLite use ?
@@ -35,9 +48,23 @@ export declare function getPlaceholders(count: number, startIndex?: number): str
  * It is intentionally explicit/async: the builder otherwise runs purely off the
  * synchronous `config` singleton (defaults + any `setConfig`), which keeps
  * `bun --compile` and test behavior deterministic — auto-loading a file in the
- * background would make early queries race the load. Previously this wrote the
- * loaded config to a private `_config` variable that nothing else read, so a
- * config file silently never took effect; it now routes through `setConfig`.
+ * background would make early queries race the load.
+ *
+ * Precedence is `defaults < config file < setConfig()`. bunfig returns a fully
+ * populated object (defaults merged with the file and env), which is fine for
+ * every key the caller has not spoken for — re-applying a default on top of the
+ * singleton that already holds that default is a no-op. It is NOT fine for keys
+ * an embedder set through `setConfig()`: those came back as library defaults and
+ * silently overwrote the embedder's choice. `setConfig({ snapshotDir })`
+ * followed by a `generateMigration()` (which calls this) reverted the snapshot
+ * to `.qb` and wrote generated state into the project root.
+ *
+ * So the loaded object is applied with those keys filtered out — an explicit API
+ * call is a stronger signal than a file that may not know the embedder exists.
+ *
+ * Note the load MUST pass `defaultConfig`: bunfig derives the environment
+ * variable names it recognises (`QUERY_BUILDER_*`) from the shape of the
+ * defaults, so passing an empty object silently drops env-var support.
  */
 export declare function getConfig(): Promise<QueryBuilderConfig>;
 export declare function setConfig(userConfig: Partial<QueryBuilderConfig>): void;

package/dist/db.d.ts

@@ -9,6 +9,18 @@ export declare function splitSqlStatements(sql: string): string[];
  * unit tests — the same pattern as `resolvePoolOptions`/`splitSqlStatements`.
  * It is not re-exported from `src/index.ts`, so it stays internal.
  */
+/**
+ * The database the library is actually connected to.
+ *
+ * Resolved the same way `createConnectionString` resolves it: the configured
+ * name, with `DB_DATABASE` taking precedence, quotes stripped. The
+ * information_schema lookups in `db:wipe` and `db:optimize` used to read
+ * `process.env.DB_NAME` — a variable this library neither documents nor reads
+ * anywhere else — and fall back to the literal `'test'`, so on MySQL they
+ * listed the tables of whatever database happened to be called `test` and
+ * silently did nothing to the real one.
+ */
+export declare function resolveDatabaseName(dbConfig?: DatabaseConfig): string;
 export declare function createConnectionString(dialect: SupportedDialect, dbConfig: DatabaseConfig): string;
 /**
  * Map the qb-level `pool` config (ms-based, ergonomic) onto the Bun SQL
@@ -38,6 +50,12 @@ export declare function getOrCreateBunSql(forceNew?: boolean): SQL;
 export declare function resetConnection(): void;
 /**
  * Inject a custom SQL instance. Useful for tests or custom connection setups.
+ *
+ * The signature is stamped alongside it so `getOrCreateBunSql()` treats the
+ * injected instance as current: leaving it null would read as "config changed"
+ * on the very next call and the injection would be discarded before it was ever
+ * used. It also means a later `setConfig()` that changes the connection still
+ * invalidates the injected instance, which is the point of the signature.
  */
 export declare function setSqlInstance(sql: SQL): void;
 // Wrapper that catches "Connection closed" errors and retries with a fresh connection

package/dist/inflect.d.ts

@@ -16,6 +16,23 @@
  * live schemas, so `'stripTrailingS'` remains the default and the corrected
  * behavior is opt-in via `relations.singularizeStrategy: 'inflect'`.
  */
+/**
+ * The conventional table name for a model that does not declare one.
+ *
+ * The ORM has always resolved this properly — snake_case, then the same
+ * pluralization rules `inflectSingular` inverts — while the schema, meta and
+ * migration layers each fell back to `name.toLowerCase() + 's'`. For any model
+ * whose name is not a bare-`s` plural that is a silent split: the generator
+ * created `categorys` and `blogposts` while the ORM read and wrote
+ * `categories` and `blog_posts`, so the migration built a table the runtime
+ * never touched.
+ *
+ * `OrderItem` -> `order_items`, `Category` -> `categories`,
+ * `Address` -> `addresses`, `Box` -> `boxes`.
+ */
+export declare function toTableName(modelName: string): string;
+/** The table a model definition resolves to: its own `table`, or the convention. */
+export declare function tableNameFor(model: { table?: unknown, name?: unknown }): string;
 /** Naive trailing-`s` strip — the historical default. */
 export declare function stripTrailingS(name: string): string;
 /**

package/dist/migrations.d.ts

@@ -1,5 +1,15 @@
 import type { ModelRecord, OnForeignKeyAction } from './schema';
 import type { SupportedDialect } from './types';
+/** The files written by the most recent generate run, in creation order. */
+export declare function lastCreatedMigrationFiles(): string[];
+/** True when this SQL was written by the generator rather than by a person. */
+export declare function isGeneratedMigrationSql(sql: string): boolean;
+/**
+ * The comparable body of a migration: its statements, with the provenance
+ * header, comments and whitespace taken out. Two files with the same body do
+ * the same thing to the schema, whatever they are called.
+ */
+export declare function migrationBody(sql: string): string;
 export declare function buildMigrationPlan(models: ModelRecord, options: InferenceOptions): MigrationPlan;
 export declare function generateSql(plan: MigrationPlan, opts?: { dryRun?: boolean }): string[];
 /**
@@ -51,6 +61,21 @@ export declare function generateDiffOperations(previous: MigrationPlan | undefin
  * callers that only need the raw statements.
  */
 export declare function generateDiffSql(previous: MigrationPlan | undefined, next: MigrationPlan, opts?: DiffOptions): string[];
+/**
+ * Header stamped onto every migration file this generator writes.
+ *
+ * Provenance, not decoration. The runner treats generated ALTER migrations as
+ * transient — replayed rather than recorded, and deleted once applied — and it
+ * used to decide that from the FILENAME. A hand-written
+ * `0000000131-alter-farms-table.sql` is a perfectly natural name for a person
+ * to choose, and it was deleted off their disk the first time they migrated.
+ * A marker the generator writes and a human does not is the only signal that
+ * actually distinguishes the two.
+ *
+ * Files without it are treated as authored, which is the safe reading: they
+ * are recorded, run once, and never removed.
+ */
+export declare const GENERATED_MARKER: '-- qb:generated';
 export declare interface ColumnPlan {
   name: string
   type: NormalizedColumnType
@@ -121,6 +146,7 @@ export declare interface InferenceOptions {
 export declare interface DiffOptions {
   applyRenames?: boolean
   dryRun?: boolean
+  preserveUnknownColumns?: boolean
 }
 export type PrimitiveDefault = string | number | boolean | bigint | Date;
 export type NormalizedColumnType = | 'string'