rado 0.1.62 → 0.1.63

package/dist/define/Update.d.ts

@@ -1,4 +1,4 @@
-import type { EV } from './Expr';
-export type Update<Row> = Partial<{
-    [K in keyof Row]: EV<Row[K]>;
-}>;
+import type { EV } from './Expr';
+export type Update<Row> = Partial<{
+    [K in keyof Row]: EV<Row[K]>;
+}>;

package/dist/driver/better-sqlite3.d.ts

@@ -1,15 +1,15 @@
-import type { Database } from 'better-sqlite3';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class BetterSqlite3Driver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    constructor(db: Database);
-    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): BetterSqlite3Driver;
+import type { Database } from 'better-sqlite3';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class BetterSqlite3Driver extends Driver.Sync {
+    db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    constructor(db: Database);
+    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): BetterSqlite3Driver;

package/dist/driver/bun-sqlite.d.ts

@@ -1,18 +1,18 @@
-/// <reference types="bun-types" />
-import type { Database } from 'bun:sqlite';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class BunSqliteDriver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    lastChanges: () => {
-        rowsAffected: number;
-    };
-    constructor(db: Database);
-    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-}
-export declare function connect(db: Database): BunSqliteDriver;
+/// <reference types="bun-types" />
+import type { Database } from 'bun:sqlite';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class BunSqliteDriver extends Driver.Sync {
+    db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    lastChanges: () => {
+        rowsAffected: number;
+    };
+    constructor(db: Database);
+    prepareStatement(stmt: Statement): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+}
+export declare function connect(db: Database): BunSqliteDriver;

package/dist/driver/sql.js.d.ts

@@ -1,15 +1,15 @@
-import type { Database } from 'sql.js';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class SqlJsDriver extends Driver.Sync {
-    db: Database;
-    tableData: (tableName: string) => Array<SqliteSchema.Column>;
-    indexData: (tableName: string) => Array<SqliteSchema.Index>;
-    constructor(db: Database);
-    prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
-    schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    export(): Uint8Array;
-}
-export declare function connect(db: Database): SqlJsDriver;
+import type { Database } from 'sql.js';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class SqlJsDriver extends Driver.Sync {
+    db: Database;
+    tableData: (tableName: string) => Array<SqliteSchema.Column>;
+    indexData: (tableName: string) => Array<SqliteSchema.Index>;
+    constructor(db: Database);
+    prepareStatement(stmt: Statement, discardAfter: boolean): Driver.Sync.PreparedStatement;
+    schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    export(): Uint8Array;
+}
+export declare function connect(db: Database): SqlJsDriver;

package/dist/driver/sqlite3.d.ts

@@ -1,18 +1,18 @@
-import type { Database } from 'sqlite3';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Driver } from '../lib/Driver';
-import { Statement } from '../lib/Statement';
-import { SqliteSchema } from '../sqlite/SqliteSchema';
-export declare class Sqlite3Driver extends Driver.Async {
-    private db;
-    lock: Promise<void> | undefined;
-    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
-    indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
-    constructor(db: Database);
-    executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
-    prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: Driver.Async, release: () => Promise<void>];
-}
-export declare function connect(db: Database): Sqlite3Driver;
+import type { Database } from 'sqlite3';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Driver } from '../lib/Driver';
+import { Statement } from '../lib/Statement';
+import { SqliteSchema } from '../sqlite/SqliteSchema';
+export declare class Sqlite3Driver extends Driver.Async {
+    private db;
+    lock: Promise<void> | undefined;
+    tableData: (tableName: string) => Promise<Array<SqliteSchema.Column>>;
+    indexData: (tableName: string) => Promise<Array<SqliteSchema.Index>>;
+    constructor(db: Database);
+    executeQuery<T>(query: Query<T>, stmt?: Driver.Async.PreparedStatement, params?: any[] | undefined): Promise<T>;
+    prepareStatement(stmt: Statement): Driver.Async.PreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: Driver.Async, release: () => Promise<void>];
+}
+export declare function connect(db: Database): Sqlite3Driver;

package/dist/index.d.ts

@@ -1,21 +1,21 @@
-export * from './define/Column';
-export * from './define/Cursor';
-export * from './define/Expr';
-export * from './define/Fields';
-export * from './define/Functions';
-export * from './define/Id';
-export * from './define/Index';
-export * from './define/Ops';
-export * from './define/OrderBy';
-export * from './define/Param';
-export * from './define/Query';
-export * from './define/Schema';
-export * from './define/Selection';
-export * from './define/Table';
-export * from './define/Target';
-export * from './define/Update';
-export type { Driver } from './lib/Driver';
-export type { FormatContext, Formatter } from './lib/Formatter';
-export type { Sanitizer } from './lib/Sanitizer';
-export * from './lib/SqlError';
-export type { Statement } from './lib/Statement';
+export * from './define/Column';
+export * from './define/Cursor';
+export * from './define/Expr';
+export * from './define/Fields';
+export * from './define/Functions';
+export * from './define/Id';
+export * from './define/Index';
+export * from './define/Ops';
+export * from './define/OrderBy';
+export * from './define/Param';
+export * from './define/Query';
+export * from './define/Schema';
+export * from './define/Selection';
+export * from './define/Table';
+export * from './define/Target';
+export * from './define/Update';
+export type { Driver } from './lib/Driver';
+export type { FormatContext, Formatter } from './lib/Formatter';
+export type { Sanitizer } from './lib/Sanitizer';
+export * from './lib/SqlError';
+export type { Statement } from './lib/Statement';

package/dist/lib/Driver.d.ts

@@ -1,110 +1,110 @@
-import { Cursor } from '../define/Cursor';
-import { Expr } from '../define/Expr';
-import { Query } from '../define/Query';
-import { SchemaInstructions } from '../define/Schema';
-import { Table } from '../define/Table';
-import { Formatter } from './Formatter';
-import { Statement } from './Statement';
-declare class Callable extends Function {
-    constructor(fn: Function);
-}
-declare abstract class DriverBase extends Callable {
-    formatter: Formatter;
-    constructor(formatter: Formatter);
-    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
-    all(...args: Array<any>): any;
-    get(...args: Array<any>): any;
-    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
-    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
-    abstract executeQuery(query: Query<any>): any;
-}
-type ParamTypes<Params extends [...any[]]> = {
-    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
-} & {
-    length: Params['length'];
-};
-interface SyncDriver {
-    <T>(query: Cursor<T>): T;
-    <T>(...queries: Array<Cursor<any>>): T;
-    (strings: TemplateStringsArray, ...values: any[]): any;
-}
-declare abstract class SyncDriver extends DriverBase {
-    transactionId: number;
-    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
-    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
-    migrateSchema(...tables: Array<Table<any>>): unknown;
-    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
-    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
-    all<T>(cursor: Cursor<T>): T;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
-    get<T>(cursor: Cursor<T>): T;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
-    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
-    transaction<T>(run: (query: SyncDriver) => T): T;
-    toAsync(): SyncWrapper;
-}
-interface SyncPreparedStatement {
-    run(params?: Array<any>): {
-        rowsAffected: number;
-    };
-    iterate<T>(params?: Array<any>): Iterable<T>;
-    all<T>(params?: Array<any>): Array<T>;
-    get<T>(params?: Array<any>): T;
-    execute(params?: Array<any>): void;
-}
-interface AsyncDriver {
-    <T>(query: Cursor<T>): Promise<T>;
-    <T>(...queries: Array<Cursor<any>>): Promise<T>;
-    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
-}
-declare abstract class AsyncDriver extends DriverBase {
-    transactionId: number;
-    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
-    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
-    all<T>(cursor: Cursor<T>): Promise<T>;
-    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
-    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
-    get<T>(cursor: Cursor<T>): Promise<T>;
-    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
-    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
-    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
-}
-declare class SyncWrapper extends AsyncDriver {
-    private sync;
-    lock: Promise<void> | undefined;
-    constructor(sync: SyncDriver);
-    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
-    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
-    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
-    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
-}
-interface AsyncPreparedStatement {
-    run(params?: Array<any>): Promise<{
-        rowsAffected: number;
-    }>;
-    iterate<T>(params?: Array<any>): AsyncIterable<T>;
-    all<T>(params?: Array<any>): Promise<Array<T>>;
-    get<T>(params?: Array<any>): Promise<T>;
-    execute(params?: Array<any>): Promise<void>;
-}
-export type Driver = SyncDriver | AsyncDriver;
-export declare namespace Driver {
-    type Sync = SyncDriver;
-    const Sync: typeof SyncDriver;
-    namespace Sync {
-        type PreparedStatement = SyncPreparedStatement;
-    }
-    type Async = AsyncDriver;
-    const Async: typeof AsyncDriver;
-    namespace Async {
-        type PreparedStatement = AsyncPreparedStatement;
-    }
-}
-export {};
+import { Cursor } from '../define/Cursor';
+import { Expr } from '../define/Expr';
+import { Query } from '../define/Query';
+import { SchemaInstructions } from '../define/Schema';
+import { Table } from '../define/Table';
+import { Formatter } from './Formatter';
+import { Statement } from './Statement';
+declare class Callable extends Function {
+    constructor(fn: Function);
+}
+declare abstract class DriverBase extends Callable {
+    formatter: Formatter;
+    constructor(formatter: Formatter);
+    compile<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): [Query<T>, Statement];
+    all(...args: Array<any>): any;
+    get(...args: Array<any>): any;
+    sql(strings: TemplateStringsArray, ...params: Array<any>): Cursor<unknown>;
+    executeTemplate(expectedReturn: Query.RawReturn, strings: TemplateStringsArray, ...params: Array<any>): any;
+    abstract executeQuery(query: Query<any>): any;
+}
+type ParamTypes<Params extends [...any[]]> = {
+    [K in keyof Params]: Params[K] extends Expr<infer T> ? T : never;
+} & {
+    length: Params['length'];
+};
+interface SyncDriver {
+    <T>(query: Cursor<T>): T;
+    <T>(...queries: Array<Cursor<any>>): T;
+    (strings: TemplateStringsArray, ...values: any[]): any;
+}
+declare abstract class SyncDriver extends DriverBase {
+    transactionId: number;
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): SyncPreparedStatement;
+    abstract schemaInstructions(tableName: string): SchemaInstructions | undefined;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => R;
+    migrateSchema(...tables: Array<Table<any>>): unknown;
+    executeQuery<T>(query: Query<T>, stmt?: SyncPreparedStatement, params?: Array<any>): T;
+    all<T>(cursor: Cursor.SelectSingle<T>): Array<T>;
+    all<T>(cursor: Cursor<T>): T;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Array<T>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): T | null;
+    get<T>(cursor: Cursor<T>): T;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): T;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): Iterable<T>;
+    transaction<T>(run: (query: SyncDriver) => T): T;
+    toAsync(): SyncWrapper;
+}
+interface SyncPreparedStatement {
+    run(params?: Array<any>): {
+        rowsAffected: number;
+    };
+    iterate<T>(params?: Array<any>): Iterable<T>;
+    all<T>(params?: Array<any>): Array<T>;
+    get<T>(params?: Array<any>): T;
+    execute(params?: Array<any>): void;
+}
+interface AsyncDriver {
+    <T>(query: Cursor<T>): Promise<T>;
+    <T>(...queries: Array<Cursor<any>>): Promise<T>;
+    (strings: TemplateStringsArray, ...values: any[]): Promise<any>;
+}
+declare abstract class AsyncDriver extends DriverBase {
+    transactionId: number;
+    abstract isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+    abstract prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    abstract schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    prepare<T extends Array<Expr<any>>, R>(create: (...params: T) => Cursor<R>): (...params: ParamTypes<T>) => Promise<R>;
+    migrateSchema(...tables: Array<Table<any>>): Promise<unknown>;
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    all<T>(cursor: Cursor.SelectSingle<T>): Promise<Array<T>>;
+    all<T>(cursor: Cursor<T>): Promise<T>;
+    all<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<Array<T>>;
+    get<T>(cursor: Cursor.SelectMultiple<T>): Promise<T | null>;
+    get<T>(cursor: Cursor<T>): Promise<T>;
+    get<T>(strings: TemplateStringsArray, ...params: Array<any>): Promise<T>;
+    iterate<T>(cursor: Cursor.SelectMultiple<T>): AsyncIterable<T>;
+    transaction<T>(run: (query: AsyncDriver) => T): Promise<T>;
+}
+declare class SyncWrapper extends AsyncDriver {
+    private sync;
+    lock: Promise<void> | undefined;
+    constructor(sync: SyncDriver);
+    executeQuery<T>(query: Query<T>, stmt?: AsyncPreparedStatement, params?: Array<any>): Promise<T>;
+    prepareStatement(stmt: Statement, discardAfter: boolean): AsyncPreparedStatement;
+    schemaInstructions(tableName: string): Promise<SchemaInstructions | undefined>;
+    isolate(): [connection: AsyncDriver, release: () => Promise<void>];
+}
+interface AsyncPreparedStatement {
+    run(params?: Array<any>): Promise<{
+        rowsAffected: number;
+    }>;
+    iterate<T>(params?: Array<any>): AsyncIterable<T>;
+    all<T>(params?: Array<any>): Promise<Array<T>>;
+    get<T>(params?: Array<any>): Promise<T>;
+    execute(params?: Array<any>): Promise<void>;
+}
+export type Driver = SyncDriver | AsyncDriver;
+export declare namespace Driver {
+    type Sync = SyncDriver;
+    const Sync: typeof SyncDriver;
+    namespace Sync {
+        type PreparedStatement = SyncPreparedStatement;
+    }
+    type Async = AsyncDriver;
+    const Async: typeof AsyncDriver;
+    namespace Async {
+        type PreparedStatement = AsyncPreparedStatement;
+    }
+}
+export {};

package/dist/lib/Formatter.d.ts

@@ -1,81 +1,81 @@
-import { ColumnData, ColumnType } from '../define/Column';
-import { ExprData } from '../define/Expr';
-import { OrderBy } from '../define/OrderBy';
-import { Query } from '../define/Query';
-import { Target } from '../define/Target';
-import { Sanitizer } from './Sanitizer';
-import { Statement, StatementOptions } from './Statement';
-export interface FormatContext {
-    stmt: Statement;
-    nameResult?: string;
-    /** Skip prefixing fields with their table name */
-    skipTableName?: boolean;
-    /**
-     * In SQLite table names are used as expressions in the FTS5 plugin.
-     * To distinguish between formatting a row of the table and just the table name
-     * this flag can be used.
-     **/
-    tableAsExpr?: boolean;
-    /** Inline all parameters */
-    forceInline?: boolean;
-    formatAsJson?: boolean;
-    formatAsInsert?: boolean;
-    formatAsIn?: boolean;
-    topLevel?: boolean;
-}
-type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
-export interface CompileOptions extends Partial<FormatContext>, StatementOptions {
-}
-export declare abstract class Formatter implements Sanitizer {
-    constructor();
-    abstract escapeValue(value: any): string;
-    abstract escapeIdentifier(ident: string): string;
-    abstract formatParamValue(paramValue: any): any;
-    abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    compile<T>(query: Query<T>, options?: CompileOptions): Statement;
-    createContext(options?: CompileOptions): {
-        stmt: Statement;
-        nameResult?: string | undefined;
-        skipTableName?: boolean | undefined;
-        tableAsExpr?: boolean | undefined;
-        forceInline?: boolean | undefined;
-        formatAsJson?: boolean | undefined;
-        formatAsInsert?: boolean | undefined;
-        formatAsIn?: boolean | undefined;
-        topLevel?: boolean | undefined;
-        skipNewlines?: boolean | undefined;
-    };
-    format<T>(ctx: FormatContext, query: Query<T>): Statement;
-    formatSelect({ topLevel, ...ctx }: FormatContext, query: Query.Select): Statement;
-    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
-    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
-    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
-    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
-    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
-    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
-    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
-    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
-    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
-    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
-    formatColumn(ctx: FormatContext, column: ColumnData): Statement;
-    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
-    formatType(ctx: FormatContext, type: ColumnType): Statement;
-    formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
-    formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;
-    formatTarget(ctx: FormatContext, target: Target): Statement;
-    formatWhere({ topLevel, ...ctx }: FormatContext, expr: ExprData | undefined): Statement;
-    formatHaving({ topLevel, ...ctx }: FormatContext, expr: ExprData | undefined): Statement;
-    formatGroupBy(ctx: FormatContext, groupBy: Array<ExprData> | undefined): Statement;
-    formatOrderBy(ctx: FormatContext, orderBy: Array<OrderBy> | undefined): Statement;
-    formatLimit(ctx: FormatContext, { limit, offset, singleResult }: Query.QueryBase): Statement;
-    formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
-    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
-    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
-    retrieveField(expr: ExprData, field: string): ExprData | undefined;
-    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
-    formatString(ctx: FormatContext, input: string): Statement;
-    formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
-    formatValue(ctx: FormatContext, rawValue: any): Statement;
-    formatExpr({ formatAsIn, ...ctx }: FormatContext, expr: ExprData): Statement;
-}
-export {};
+import { ColumnData, ColumnType } from '../define/Column';
+import { ExprData } from '../define/Expr';
+import { OrderBy } from '../define/OrderBy';
+import { Query } from '../define/Query';
+import { Target } from '../define/Target';
+import { Sanitizer } from './Sanitizer';
+import { Statement, StatementOptions } from './Statement';
+export interface FormatContext {
+    stmt: Statement;
+    nameResult?: string;
+    /** Skip prefixing fields with their table name */
+    skipTableName?: boolean;
+    /**
+     * In SQLite table names are used as expressions in the FTS5 plugin.
+     * To distinguish between formatting a row of the table and just the table name
+     * this flag can be used.
+     **/
+    tableAsExpr?: boolean;
+    /** Inline all parameters */
+    forceInline?: boolean;
+    formatAsJson?: boolean;
+    formatAsInsert?: boolean;
+    formatAsIn?: boolean;
+    topLevel?: boolean;
+}
+type FormatSubject = (stmt: Statement, mkSubject: () => void) => void;
+export interface CompileOptions extends Partial<FormatContext>, StatementOptions {
+}
+export declare abstract class Formatter implements Sanitizer {
+    constructor();
+    abstract escapeValue(value: any): string;
+    abstract escapeIdentifier(ident: string): string;
+    abstract formatParamValue(paramValue: any): any;
+    abstract formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
+    compile<T>(query: Query<T>, options?: CompileOptions): Statement;
+    createContext(options?: CompileOptions): {
+        stmt: Statement;
+        nameResult?: string | undefined;
+        skipTableName?: boolean | undefined;
+        tableAsExpr?: boolean | undefined;
+        forceInline?: boolean | undefined;
+        formatAsJson?: boolean | undefined;
+        formatAsInsert?: boolean | undefined;
+        formatAsIn?: boolean | undefined;
+        topLevel?: boolean | undefined;
+        skipNewlines?: boolean | undefined;
+    };
+    format<T>(ctx: FormatContext, query: Query<T>): Statement;
+    formatSelect({ topLevel, ...ctx }: FormatContext, query: Query.Select): Statement;
+    formatInsert(ctx: FormatContext, query: Query.Insert): Statement;
+    formatUpdate(ctx: FormatContext, query: Query.Update): Statement;
+    formatDelete(ctx: FormatContext, query: Query.Delete): Statement;
+    formatCreateTable(ctx: FormatContext, query: Query.CreateTable): Statement;
+    formatCreateIndex(ctx: FormatContext, query: Query.CreateIndex): Statement;
+    formatDropIndex(ctx: FormatContext, query: Query.DropIndex): Statement;
+    formatAlterTable(ctx: FormatContext, query: Query.AlterTable): Statement;
+    formatTransaction(ctx: FormatContext, { op, id }: Query.Transaction): Statement;
+    formatBatch(ctx: FormatContext, { queries }: Query.Batch): Statement;
+    formatRaw(ctx: FormatContext, { strings, params }: Query.Raw): Statement;
+    formatColumn(ctx: FormatContext, column: ColumnData): Statement;
+    formatContraintReference(ctx: FormatContext, reference: ExprData): Statement;
+    formatType(ctx: FormatContext, type: ColumnType): Statement;
+    formatInsertRow(ctx: FormatContext, columns: Record<string, ColumnData>, row: Record<string, any>): Statement;
+    formatColumnValue(ctx: FormatContext, column: ColumnData, columnValue: any): Statement;
+    formatTarget(ctx: FormatContext, target: Target): Statement;
+    formatWhere({ topLevel, ...ctx }: FormatContext, expr: ExprData | undefined): Statement;
+    formatHaving({ topLevel, ...ctx }: FormatContext, expr: ExprData | undefined): Statement;
+    formatGroupBy(ctx: FormatContext, groupBy: Array<ExprData> | undefined): Statement;
+    formatOrderBy(ctx: FormatContext, orderBy: Array<OrderBy> | undefined): Statement;
+    formatLimit(ctx: FormatContext, { limit, offset, singleResult }: Query.QueryBase): Statement;
+    formatSelection(ctx: FormatContext, selection: ExprData, formatSubject?: FormatSubject): Statement;
+    formatExprJson(ctx: FormatContext, expr: ExprData): Statement;
+    formatExprValue(ctx: FormatContext, expr: ExprData): Statement;
+    retrieveField(expr: ExprData, field: string): ExprData | undefined;
+    formatField(ctx: FormatContext, expr: ExprData, field: string): Statement;
+    formatString(ctx: FormatContext, input: string): Statement;
+    formatInlineValue(ctx: FormatContext, rawValue: any): Statement;
+    formatValue(ctx: FormatContext, rawValue: any): Statement;
+    formatExpr({ formatAsIn, ...ctx }: FormatContext, expr: ExprData): Statement;
+}
+export {};

package/dist/lib/Formatter.js

@@ -410,7 +410,7 @@ var Formatter = class {
     if (formatSubject)
       formatSubject(stmt, mkSubject);
     else
-      mkSubject();
+      this.formatExpr(ctx, selection);
     stmt.add("AS").addIdentifier("result");
     return stmt;
   }
@@ -624,7 +624,7 @@ var Formatter = class {
               stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
             }
             stmt.raw("SELECT value AS result").add("FROM json_each").openParenthesis();
-            this.formatExprJson(ctx, target.expr);
+            this.formatExpr(ctx, target.expr);
             stmt.closeParenthesis();
             if (target.alias)
               stmt.add("AS").addIdentifier(target.alias);
@@ -647,7 +647,7 @@ var Formatter = class {
               stmt.raw("SELECT json_group_array(json(result)) FROM ").openParenthesis();
             }
             stmt.raw("SELECT").space();
-            this.formatExprJson(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
+            this.formatExpr(ctx, result).add("AS result").add("FROM json_each").openParenthesis();
             this.formatExprJson(ctx, target.expr);
             stmt.closeParenthesis();
             if (target.alias)

package/dist/lib/Sanitizer.d.ts

@@ -1,5 +1,5 @@
-export interface Sanitizer {
-    escapeValue(value: any): string;
-    escapeIdentifier(ident: string): string;
-    formatParamValue(paramValue: any): any;
-}
+export interface Sanitizer {
+    escapeValue(value: any): string;
+    escapeIdentifier(ident: string): string;
+    formatParamValue(paramValue: any): any;
+}

package/dist/lib/SqlError.d.ts

@@ -1,3 +1,3 @@
-export declare class SqlError extends Error {
-    constructor(cause: Error, sql: string);
-}
+export declare class SqlError extends Error {
+    constructor(cause: Error, sql: string);
+}