bun-query-builder 0.1.40 → 0.1.44

package/dist/config.d.ts

@@ -1,4 +1,13 @@
-import type { QueryBuilderConfig } from './types';
+import type { QueryBuilderConfig, SupportedDialect } from './types';
+/**
+ * Whether a dialect belongs to the MySQL wire-protocol family (MySQL itself or
+ * SingleStore). These share `?` placeholders, backtick identifier quoting,
+ * `ON DUPLICATE KEY UPDATE` upserts, `LAST_INSERT_ID()` id recovery, and the
+ * `YYYY-MM-DD HH:MM:SS` datetime literal shape. Runtime DML branches should key
+ * off this helper rather than `dialect === 'mysql'` so SingleStore inherits the
+ * same behavior; only DDL (see `SingleStoreDriver`) diverges.
+ */
+export declare function isMysqlLike(dialect?: SupportedDialect): boolean;
 /**
  * Get the placeholder format for the current dialect.
  * PostgreSQL uses $1, $2, $3... while MySQL and SQLite use ?

package/dist/db.d.ts

@@ -1,6 +1,7 @@
 import { Database } from 'bun:sqlite';
 import { SQL } from 'bun';
 import type { PoolConfig } from './types';
+export declare function splitSqlStatements(sql: string): string[];
 /**
  * Map the qb-level `pool` config (ms-based, ergonomic) onto the Bun SQL
  * driver's native option names (second resolution). Only the knobs Bun's

package/dist/drivers/index.d.ts

@@ -1,5 +1,6 @@
 import { MySQLDriver } from './mysql';
 import { PostgresDriver } from './postgres';
+import { SingleStoreDriver } from './singlestore';
 import { SQLiteDriver } from './sqlite';
 import type { DialectDriver } from './postgres';
 import type { SupportedDialect } from '../types';
@@ -29,6 +30,7 @@ export type {
 export declare function getDialectDriver(dialect: SupportedDialect): DialectDriver;
 export { MySQLDriver } from './mysql';
 export { PostgresDriver } from './postgres';
+export { SingleStoreDriver } from './singlestore';
 export { SQLiteDriver } from './sqlite';
 // DynamoDB driver (NoSQL)
 export {

package/dist/drivers/mysql.d.ts

@@ -18,6 +18,11 @@ export declare interface DialectDriver {
   recordMigrationQuery: () => string
 }
 export declare class MySQLDriver implements DialectDriver {
+  protected quoteIdentifier(id: string): string;
+  protected getColumnType(column: ColumnPlan): string;
+  protected getPrimaryKeyType(column: ColumnPlan): string;
+  protected getAutoIncrementClause(column: ColumnPlan): string;
+  protected getDefaultValue(column: ColumnPlan): string;
   createEnumType(_enumTypeName: string, _values: string[]): string;
   createTable(table: TablePlan): string;
   createIndex(tableName: string, index: IndexPlan): string;
@@ -34,4 +39,5 @@ export declare class MySQLDriver implements DialectDriver {
   createMigrationsTable(): string;
   getExecutedMigrationsQuery(): string;
   recordMigrationQuery(): string;
+  protected renderColumn(column: ColumnPlan): string;
 }

package/dist/drivers/singlestore.d.ts

@@ -0,0 +1,28 @@
+import { MySQLDriver } from './mysql';
+import type { IndexPlan, TablePlan } from '../migrations';
+/**
+ * SingleStore DDL driver.
+ *
+ * SingleStore (formerly MemSQL) speaks the MySQL wire protocol, so runtime DML
+ * (placeholders, backtick quoting, `ON DUPLICATE KEY UPDATE`, `LAST_INSERT_ID`)
+ * is identical — see `isMysqlLike` in `config.ts`. Only the DDL diverges, which
+ * is what this driver customizes:
+ *
+ *  - **Distributed tables.** Rows are hash-partitioned across leaf nodes by a
+ *    `SHARD KEY`. When a model declares `shardKey`, we emit it; otherwise
+ *    SingleStore shards on the primary key (or a random key for columnstore),
+ *    so a plain MySQL-shaped `CREATE TABLE` still works.
+ *  - **Storage engine.** `tableKind: 'columnstore'` (default for analytics
+ *    workloads) emits `SORT KEY (...)`; `'rowstore'` emits `ROWSTORE`;
+ *    `'reference'` emits a `REFERENCE` table (fully replicated, no shard key —
+ *    ideal for small dimension tables that get JOINed everywhere).
+ *  - **No foreign keys.** SingleStore does not support `FOREIGN KEY`
+ *    constraints, so `addForeignKey` is a no-op (referential integrity is an
+ *    application concern). This mirrors how the MySQL driver already treats
+ *    enums (`createEnumType` → '').
+ */
+export declare class SingleStoreDriver extends MySQLDriver {
+  createTable(table: TablePlan): string;
+  addForeignKey(): string;
+  createIndex(tableName: string, index: IndexPlan): string;
+}

package/dist/drivers/sqlite.d.ts

@@ -1,4 +1,10 @@
 import type { ColumnPlan, IndexPlan, RebuildTableSpec, TablePlan } from '../migrations';
+/**
+ * Whether a plan type belongs to the numeric family. Used by the `_id`
+ * safety net (numeric ids must store as INTEGER on SQLite) — non-numeric
+ * declared types must never be coerced by the name heuristic.
+ */
+export declare function isNumericPlanType(type: string | undefined): boolean;
 export declare interface DialectDriver {
   createEnumType: (enumTypeName: string, values: string[]) => string
   createTable: (table: TablePlan) => string

package/dist/index.d.ts

@@ -40,6 +40,7 @@ export * from './pivot';
 export * from './orm';
 export * from './schema';
 export * from './seeder';
+export * from './sqlite-pragmas';
 export * from './type-inference';
 export * from './types';
 export { type ModelDefinition, defineModel } from './model';

package/dist/migrations.d.ts

@@ -61,6 +61,8 @@ export declare interface ColumnPlan {
   defaultValue?: PrimitiveDefault
   references?: { table: string, column: string, onDelete?: OnForeignKeyAction, onUpdate?: OnForeignKeyAction }
   enumValues?: string[]
+  maxLength?: number
+  enumTypeName?: string
 }
 export declare interface IndexPlan {
   name: string
@@ -72,6 +74,9 @@ export declare interface TablePlan {
   table: string
   columns: ColumnPlan[]
   indexes: IndexPlan[]
+  shardKey?: string[]
+  sortKey?: string[]
+  tableKind?: 'rowstore' | 'columnstore' | 'reference'
 }
 export declare interface MigrationPlan {
   dialect: SupportedDialect

package/dist/sqlite-pragmas.d.ts

@@ -0,0 +1,30 @@
+import type { Database } from 'bun:sqlite';
+/** The pragma list currently in effect: the config override, or the defaults. */
+export declare function resolveSqlitePragmas(): readonly string[];
+/**
+ * Apply the bootstrap pragmas to a freshly-opened `bun:sqlite` Database.
+ *
+ * Fail-open per pragma: a single rejected pragma (e.g. a dialect-specific
+ * one in a custom list) must not take down connection creation — matching
+ * the long-standing behavior of the WAL pragma this generalizes.
+ */
+export declare function applySqliteBootstrapPragmas(db: Database): void;
+/**
+ * Bootstrap pragmas applied to every sqlite connection the library opens.
+ *
+ * SQLite scopes these settings to the CONNECTION, not the database file, and
+ * ships with unsafe defaults on every fresh connection: `foreign_keys` is OFF
+ * (so `REFERENCES ... ON DELETE CASCADE` in the schema is silently inert and
+ * orphan rows insert without error) and there is no busy timeout (concurrent
+ * writers surface as immediate `SQLITE_BUSY` failures). They therefore have
+ * to be re-applied on every connection the library creates — historically
+ * only the query-builder connection got `journal_mode = WAL` while the
+ * model-layer executor (the connection `Model.create()/save()/delete()`
+ * writes through) got nothing at all, leaving FK enforcement off on the
+ * exact connection performing the writes.
+ *
+ * Override via `setConfig({ sqlite: { pragmas: [...] } })` — the custom list
+ * REPLACES this one. Caller-supplied `Database` instances
+ * (`configureOrm({ database: db })`) are never touched.
+ */
+export declare const DEFAULT_SQLITE_PRAGMAS: readonly string[];