bun-query-builder 0.1.21 → 0.1.24

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import type { BrowserConfig } from './types';
-import type { Faker } from 'ts-mocker';
+import type { Faker } from '@stacksjs/ts-faker';
 // Export types for external use
 export type { BrowserModelInstance, BrowserModelQueryBuilder };
 /**
@@ -56,29 +56,40 @@ export declare function createBrowserDb<Tables extends Record<string, any>>(): {
 export declare function createBrowserModel<const TDef extends BrowserModelDefinition>(definition: TDef): void;
 /**
  * Auth helpers for browser
- * @defaultValue `{ async login: () => unknown, async register: () => unknown }`
+ * @defaultValue
+ * ```ts
+ * {
+ *   login: (credentials?: { email: string, password: string }): Promise<BrowserAuthResponse> {
+ *     const response) => Promise<unknown>,
+ *   register: (data?: { name: string, email: string, password: string }): Promise<BrowserAuthResponse> {
+ *     const response) => Promise<unknown>,
+ *   logout: () => unknown,
+ *   user: () => unknown,
+ *   check: () => unknown
+ * }
+ * ```
  */
 export declare const browserAuth: {
   /**
    * Login and store token
    */
-  async login: (credentials: { email: string, password: string }) => Promise<BrowserAuthResponse>;
+  login: (credentials: { email: string, password: string }) => Promise<BrowserAuthResponse>;
   /**
    * Register a new user
    */
-  async register: (data: { name: string, email: string, password: string }) => Promise<BrowserAuthResponse>;
+  register: (data: { name: string, email: string, password: string }) => Promise<BrowserAuthResponse>;
   /**
    * Logout and clear token
    */
-  async logout: () => Promise<void>;
+  logout: () => Promise<void>;
   /**
    * Get current authenticated user
    */
-  async user: unknown;
+  user: () => Promise<Record<string, unknown> | null>;
   /**
    * Check if user is authenticated
    */
-  async check: () => Promise<boolean>;
+  check: () => Promise<boolean>;
   /**
    * Get the current token
    */

package/dist/client.d.ts

@@ -32,9 +32,9 @@ export declare interface WhereRaw {
 export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>, TTable extends keyof DB & string, TSelected, TJoined extends string = TTable,> {
   distinct: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   distinctOn: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  selectRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  selectRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   where: (expr: WhereExpression<DB[TTable]['columns']> | string, op?: WhereOperator, value?: any) => SelectQueryBuilder<DB, TTable, TSelected>
-  whereRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  whereRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereColumn: (left: string, op: WhereOperator, right: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   orWhereColumn: (left: string, op: WhereOperator, right: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   whereIn: (column: keyof DB[TTable]['columns'] & string, values: any[] | { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -100,13 +100,13 @@ export declare interface BaseSelectQueryBuilder<DB extends DatabaseSchema<any>,
   crossJoin: <T2 extends keyof DB & string>(table: T2) => SelectQueryBuilder<DB, TTable, TSelected, TJoined | T2>
   crossJoinSub: (sub: { toSQL: () => any }, alias: string) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   groupBy: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  groupByRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  groupByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   having: (expr: WhereExpression<any>) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  havingRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  havingRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   addSelect: (...columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   select?: (columns: (keyof DB[TTable]['columns'] & string | string)[]) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   selectAll?: () => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
-  orderByRaw: (fragment: any) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
+  orderByRaw: (fragment: SqlFragment) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   union: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   unionAll: (other: { toSQL: () => any }) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
   forPage: (page: number, perPage: number) => SelectQueryBuilder<DB, TTable, TSelected, TJoined>
@@ -356,6 +356,28 @@ export declare interface TransactionOptions {
 declare type Primitive = string | number | boolean | bigint | Date | null | undefined;
 declare type ValueOrRef = Primitive;
 export type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in' | 'is' | 'is not';
+/**
+ * Brand for SQL fragments produced by Bun's `sql\`...\`` tagged-template
+ * (or any equivalent helper). Typed as `object` so the *Raw methods
+ * (`whereRaw`, `selectRaw`, `groupByRaw`, `havingRaw`, `orderByRaw`)
+ * refuse to compile when passed a bare string — concatenated user
+ * input (`whereRaw(\`status = '${req.body.s}'\`)`) was the canonical
+ * SQL-injection vector flagged by the audit as Q-3.
+ *
+ * Callers who legitimately need raw SQL use `sql\`...\`` which
+ * separates the SQL fragment from parameter values:
+ *
+ * ```ts
+ * import { sql } from 'bun'
+ * db.selectFrom('users').whereRaw(sql\`lower(name) = lower(${input})\`)
+ * ```
+ *
+ * The runtime guard in each *Raw method also rejects bare strings as
+ * a defense-in-depth backstop for `as any` casts.
+ *
+ * See stacksjs/stacks#1858 Q-3.
+ */
+export type SqlFragment = object;
 export type WhereExpression<TableColumns> = | Partial<{ [K in keyof TableColumns & string]: ValueOrRef | ValueOrRef[] }>
   | [key: keyof TableColumns & string, op: WhereOperator, value: ValueOrRef | ValueOrRef[]]
   | WhereRaw;

package/dist/config.d.ts

@@ -11,11 +11,6 @@ export declare function getPlaceholder(index: number): string;
  */
 export declare function getPlaceholders(count: number, startIndex?: number): string;
 export declare function getConfig(): Promise<QueryBuilderConfig>;
-/**
- * Programmatically set/override the query builder configuration.
- * This is useful when you want to configure bun-query-builder from
- * your application code rather than using a config file.
- */
 export declare function setConfig(userConfig: Partial<QueryBuilderConfig>): void;
 export declare const defaultConfig: QueryBuilderConfig;
 // For backwards compatibility — synchronous access with default fallback.

package/dist/drivers/mysql.d.ts

@@ -15,5 +15,17 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class MySQLDriver implements DialectDriver {
-
+  createEnumType(_enumTypeName: string, _values: string[]): string;
+  createTable(table: TablePlan): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string): string;
+  addColumn(tableName: string, column: ColumnPlan): string;
+  modifyColumn(tableName: string, column: ColumnPlan): string;
+  dropTable(tableName: string): string;
+  dropColumn(tableName: string, columnName: string): string;
+  dropIndex(tableName: string, indexName: string): string;
+  dropEnumType(_enumTypeName: string): string;
+  createMigrationsTable(): string;
+  getExecutedMigrationsQuery(): string;
+  recordMigrationQuery(): string;
 }

package/dist/drivers/postgres.d.ts

@@ -15,5 +15,17 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class PostgresDriver implements DialectDriver {
-
+  createEnumType(enumTypeName: string, values: string[]): string;
+  createTable(table: TablePlan): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+  addForeignKey(tableName: string, columnName: string, refTable: string, refColumn: string, onDelete?: string, onUpdate?: string): string;
+  addColumn(tableName: string, column: ColumnPlan): string;
+  modifyColumn(tableName: string, column: ColumnPlan): string;
+  dropTable(tableName: string): string;
+  dropColumn(tableName: string, columnName: string): string;
+  dropIndex(tableName: string, indexName: string): string;
+  dropEnumType(enumTypeName: string): string;
+  createMigrationsTable(): string;
+  getExecutedMigrationsQuery(): string;
+  recordMigrationQuery(): string;
 }

package/dist/drivers/sqlite.d.ts

@@ -15,5 +15,17 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class SQLiteDriver implements DialectDriver {
-
+  createEnumType(_enumTypeName: string, _values: string[]): string;
+  createTable(table: TablePlan): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+  addForeignKey(_tableName: string, _columnName: string, _refTable: string, _refColumn: string, _onDelete?: string, _onUpdate?: string): string;
+  addColumn(tableName: string, column: ColumnPlan): string;
+  modifyColumn(tableName: string, column: ColumnPlan): string;
+  dropTable(tableName: string): string;
+  dropColumn(tableName: string, columnName: string): string;
+  dropIndex(tableName: string, indexName: string): string;
+  dropEnumType(_enumTypeName: string): string;
+  createMigrationsTable(): string;
+  getExecutedMigrationsQuery(): string;
+  recordMigrationQuery(): string;
 }

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 // Resolve ambiguous re-exports by explicitly choosing which module's version to use
 export type { WhereOperator } from './browser';
-export type { ModelQueryBuilder } from './dynamodb';
+export type { ModelQueryBuilder } from './dynamodb/index';
 export type { ColumnName } from './client';
 // Re-export the type-inference version of InferRelationNames (supports wrapped models)
 // to resolve the ambiguity with orm.ts's InferRelationNames (which takes raw definitions)
@@ -22,16 +22,16 @@ export type {
   ModelCreateDataLoose,
   RelationCardinality,
 } from './type-inference';
-export * from './actions';
+export * from './actions/index';
 export * from './browser';
 export * from './client';
 export * from './model';
 export * from './config';
-export * from './drivers';
+export * from './drivers/index';
 export * from './dynamodb-client';
 export * from './dynamodb-single-table';
 export * from './dynamodb-tooling-adapter';
-export * from './dynamodb';
+export * from './dynamodb/index';
 export * from './factory';
 export * from './loader';
 export * from './meta';
@@ -44,4 +44,4 @@ export * from './type-inference';
 export * from './types';
 export { type ModelDefinition, defineModel } from './model';
 // Explicit re-exports for model registry functions
-export { getModel, getAllModels, getModelRegistry, hasModel, clearModelRegistry } from './model';
+export { getModel, getAllModels, getModelRegistry, hasModel, clearModelRegistry, registerModel } from './model';

package/dist/model.d.ts

@@ -53,6 +53,18 @@ export declare function hasModel(name: string): boolean;
  * Clear all registered models. Primarily useful for testing.
  */
 export declare function clearModelRegistry(): void;
+/**
+ * Register an already-created model instance in the global registry.
+ *
+ * Framework integrations can build richer model facades themselves and
+ * still expose those models to query-builder features that discover
+ * models through the shared registry.
+ *
+ * @param name - The model name (e.g., 'User', 'Trail')
+ * @param model - The runtime model instance to register
+ * @returns The same model instance for convenient passthrough usage
+ */
+export declare function registerModel<TModel>(name: string, model: TModel): TModel;
 /**
  * Define an isomorphic model that works in both server and browser.
  *

package/dist/orm.d.ts

@@ -1,5 +1,5 @@
 import { Database, type SQLQueryBindings } from 'bun:sqlite';
-import type { Faker } from 'ts-mocker';
+import type { Faker } from '@stacksjs/ts-faker';
 export type {
   ModelInstance,
   ModelQueryBuilder,

package/dist/schema.d.ts

@@ -1,4 +1,4 @@
-import type { Faker } from 'ts-mocker';
+import type { Faker } from '@stacksjs/ts-faker';
 /**
  * # `defineModel(model)`
  *