bun-query-builder 0.2.25 → 0.2.27

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import type { QueryBuilderConfig, SupportedDialect } from './types';
+import type { QueryBuilderConfig, QueryBuilderOptions, SupportedDialect } from './types';
 /**
  * Whether a dialect belongs to the MySQL wire-protocol family (MySQL itself,
  * SingleStore, or Vitess). These share `?` placeholders, backtick identifier
@@ -9,6 +9,54 @@ import type { QueryBuilderConfig, SupportedDialect } from './types';
  * `SingleStoreDriver` / `VitessDriver`) diverges.
  */
 export declare function isMysqlLike(dialect?: SupportedDialect): boolean;
+/**
+ * Recursively merge `source` over `target`, returning a NEW object. Neither
+ * argument is mutated.
+ *
+ * The semantics below are load-bearing — each is pinned by a test or by a
+ * documented promise, so do not "simplify" them:
+ *
+ *  - ARRAYS REPLACE. They do not concatenate or union. `SqliteConfig.pragmas`
+ *    says so in its own doc comment, and `sqlite-bootstrap-pragmas.test.ts`
+ *    asserts it by checking that `foreign_keys` is still 0 after an override
+ *    that omits it — concatenation would flip that to 1.
+ *    `transactionDefaults.sqlStates` is the same shape: a user narrowing
+ *    retries to `['40002']` must stop retrying on `40001`, not keep it.
+ *
+ *  - FUNCTIONS REPLACE. `isPlainObject` rejects them, so `QueryHooks` members
+ *    and `BrowserConfig.getToken` / `transformResponse` stay opaque leaves. We
+ *    never recurse into a function's own enumerable properties.
+ *
+ *  - AN EXPLICIT `undefined` ASSIGNS; AN ABSENT KEY DOES NOT. The rule is
+ *    PRESENCE, not value — `Object.keys(source)` contains a key written as
+ *    `undefined` and does not contain one that was never written. Not a style
+ *    choice: `resolve-dialect.test.ts` calls `setConfig({ dialect: undefined })`
+ *    and expects `resolveDialect()` to fall back to `'postgres'`, and
+ *    `sqlite-bootstrap-pragmas.test.ts` uses `sqlite: undefined` as the restore
+ *    that un-does a pragma override for the rest of a shared-process run.
+ *    Skipping `undefined` breaks both, and now that `hooks` deep-merges, an
+ *    explicit `undefined` is also the only way to REMOVE a hook.
+ *
+ *  - `null` ASSIGNS and is never recursed into. No field in
+ *    `QueryBuilderConfig` is nullable, so a `null` arriving here is a caller
+ *    mistake; assigning it surfaces that at the read site instead of hiding it.
+ *
+ * Arrays are copied by REFERENCE, being leaves — `config.transactionDefaults
+ * .sqlStates` is the same array as `defaultConfig`'s until something replaces
+ * it. Nothing in `src/` mutates a config array in place (the only read is an
+ * `.includes`), and cloning on every merge is not worth paying for that.
+ *
+ * `seen` is the chain of source objects currently being merged, so a source
+ * that points back at one of its own ancestors is treated as a leaf instead of
+ * recursed into. An embedding framework's config slice — the case this type
+ * exists to serve — routinely carries a parent back-pointer, and it typechecks
+ * fine because an optional field of an interface can be that interface. Without
+ * the guard that input spins for seconds, allocates gigabytes and dies with a
+ * stack overflow. It is a DEPTH chain, pushed and popped around the recursion,
+ * not a global set: the same object legitimately appearing under two different
+ * keys must merge both times, and a global set would silently drop the second.
+ */
+declare function mergeObject(target: Record<string, unknown>, source: Record<string, unknown>, seen?: Set<object>): Record<string, unknown>;
 /**
  * The dialect a command should operate on.
  *
@@ -62,12 +110,64 @@ export declare function getPlaceholders(count: number, startIndex?: number): str
  *
  * 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.
+ * The filter is per top-level section; see `configState` for why per-leaf is
+ * the wrong granularity.
  *
  * 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;
+export declare function setConfig(userConfig: QueryBuilderOptions): void;
+/**
+ * Identity helper for a typed `query-builder.config.ts`.
+ *
+ * It exists so that writing a config file requires no decision about which
+ * type to annotate with — which is what stacksjs/bun-query-builder#1062 was
+ * actually about. The only config type this package exported was
+ * `QueryBuilderConfig`, the RESOLVED shape with every field required, and the
+ * docs told people to import it, so downstream apps annotated their config
+ * file with a type demanding `migrationDir`, `snapshotDir`, `features`,
+ * `aliasing` and nine other sections they had no opinion about. Every field
+ * added here afterwards was a downstream build break.
+ *
+ * `defineConfig` takes `QueryBuilderOptions`, so nothing is ever required, and
+ * returns its argument unchanged — there is no runtime behavior here, only the
+ * type and the editor completion that comes with it.
+ *
+ * ```ts
+ * // query-builder.config.ts
+ * import { defineConfig } from 'bun-query-builder'
+ *
+ * export default defineConfig({
+ *   dialect: 'postgres',
+ *   database: { database: 'my_app' },
+ * })
+ * ```
+ */
+export declare function defineConfig(userConfig: QueryBuilderOptions): QueryBuilderOptions;
 export declare const defaultConfig: QueryBuilderConfig;
+// The single, process-wide config object — stored on a `globalThis` symbol so
+// that EVERY copy of this module shares one object, even if Bun's bundler
+// inlines `config.ts` more than once. Previously this was an `export let` that
+// `setConfig` mutated in place: it worked, but relied on the bundler keeping a
+// never-reassigned live binding as a single shared binding, and the build had
+// to regex-patch the emitted `__esm(init_config)` wrapper to keep readers and
+// writers on the same binding. A `globalThis`-keyed `export const` removes both
+// hazards — there is no module-local binding to split or rename, and `const`
+// makes the "never reassign config" rule unenforceable-to-break.
+//
+// Notes:
+//  - `??=` so the first-evaluated copy wins and the rest reuse it.
+//  - `Symbol.for` is a process-global registry key (shared across copies). It
+//    is also shared across package versions in one process — that's the intended
+//    hardening; pin a versioned key if you ever need per-version isolation.
+//  - Synchronous + no top-level await here, so `bun --compile` is unaffected.
+//  - Seeded through `mergeObject`, not `{ ...defaultConfig }`. A shallow spread
+//    left `config.debug === defaultConfig.debug`, so the direct writes this
+//    package makes to the live config — `config.debug.captureText = true` in
+//    `actions/sql.ts` and `computeSqlText()` — were reaching into the exported
+//    DEFAULTS and permanently changing them. `mergeObject` clones every plain
+//    object node, which closes that.
+declare const CONFIG_SINGLETON_KEY: symbol;
 export declare const config: QueryBuilderConfig;

package/dist/db.d.ts

@@ -60,6 +60,11 @@ export declare function resetConnection(): void;
 export declare function setSqlInstance(sql: SQL): void;
 // Wrapper that catches "Connection closed" errors and retries with a fresh connection
 export declare function withFreshConnection<T>(fn: (sql: SQL) => Promise<T>): Promise<T>;
+/**
+ * Lazy SQL connection proxy - connection is only created when first accessed.
+ * This allows setConfig() to be called before any database connection is made.
+ */
+declare function createLazyBunSql(): SQL;
 // Export a lazy proxy - no connection is made until first use
 export declare const bunSql: SQL;
 /**

package/dist/model.d.ts

@@ -79,7 +79,7 @@ export declare function registerModel<TModel>(name: string, model: TModel): TMod
  * @param definition - The model definition
  * @returns An isomorphic model with query methods
  */
-export declare function defineModel<const TDef extends BrowserModelDefinition>(definition: TDef): void;
+export declare function defineModel<const TDef extends BrowserModelDefinition>(definition: TDef): unknown;
 /**
  * Register models on the global window.StacksBrowser object.
  * Call this in your app's entry point to make models available for STX auto-imports.

package/dist/orm.d.ts

@@ -228,7 +228,8 @@ declare type PrimitiveTypeMap = {
 declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
   T extends readonly (infer U)[] ? U :
   T extends (infer U)[] ? U :
-  T extends { validate: (value: infer U) => any } ? U :
+  T extends { validate: (value: infer U) => unknown } ? U :
+  T extends { test: (value: infer U) => unknown } ? U :
   unknown;
 // Extract attribute keys from definition
 declare type AttributeKeys<TDef extends ModelDefinition> = keyof TDef['attributes'] & string;
@@ -358,9 +359,9 @@ declare type FillableAttributes<TDef extends ModelDefinition> = Partial<Pick<
   ModelAttributes<TDef>,
   FillableKeys<TDef> | SnakeCase<FillableKeys<TDef>> | BelongsToKeys<TDef>
 >>;
-// Numeric attribute columns — constrains aggregate methods (sum, avg, etc.)
+// Numeric attribute columns - constrains aggregate methods (sum, avg, etc.)
 declare type NumericColumns<TDef extends ModelDefinition> = {
-  [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { type: 'number' } ? K : never
+  [K in AttributeKeys<TDef>]: InferAttributeType<TDef['attributes'][K]> extends number ? K : never
 }[AttributeKeys<TDef>];
 /**
  * Relation names of one relation declaration. Array form lowercases the

package/dist/schema.d.ts

@@ -62,7 +62,7 @@ export declare interface Attribute {
   fillable?: boolean
   guarded?: boolean
   foreignKey?: boolean | ForeignKeyConfig
-  factory?: (faker: Faker) => any
+  factory?: (faker: Faker) => unknown
   validation: {
     rule: ValidationType
     message?: ValidatorMessage