rado 0.1.62 → 0.1.64

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

@@ -83,8 +83,10 @@ var Formatter = class {
       query.selection,
       topLevel ? formatAsResultObject : void 0
     );
-    stmt.addLine("FROM").space();
-    this.formatTarget(ctx, query.from);
+    if (query.from) {
+      stmt.addLine("FROM").space();
+      this.formatTarget(ctx, query.from);
+    }
     this.formatWhere(ctx, query.where);
     this.formatGroupBy(ctx, query.groupBy);
     this.formatHaving(ctx, query.having);
@@ -321,8 +323,6 @@ var Formatter = class {
           throw new TypeError(`Expected boolean for column ${column.name}`);
         return stmt.raw(this.escapeValue(columnValue));
       case ColumnType.Json:
-        if (typeof columnValue !== "object")
-          throw new TypeError(`Expected object for column ${column.name}`);
         return stmt.value(JSON.stringify(columnValue));
     }
   }
@@ -390,12 +390,15 @@ var Formatter = class {
     return stmt;
   }
   formatLimit(ctx, { limit, offset, singleResult }) {
-    const { stmt } = ctx;
+    const { stmt, forceInline } = ctx;
     if (!limit && !offset && !singleResult)
       return stmt;
-    stmt.newline().raw("LIMIT").addValue(singleResult ? 1 : limit);
-    if (offset && offset > 0)
-      stmt.raw("OFFSET").addValue(offset);
+    stmt.newline().raw("LIMIT");
+    this.formatValue(ctx, singleResult ? 1 : limit);
+    if (offset && offset > 0) {
+      stmt.raw("OFFSET");
+      this.formatValue(ctx, offset);
+    }
     return stmt;
   }
   formatSelection(ctx, selection, formatSubject) {
@@ -410,7 +413,7 @@ var Formatter = class {
     if (formatSubject)
       formatSubject(stmt, mkSubject);
     else
-      mkSubject();
+      this.formatExpr(ctx, selection);
     stmt.add("AS").addIdentifier("result");
     return stmt;
   }
@@ -441,7 +444,8 @@ var Formatter = class {
           case TargetType.Table:
             const column = expr.target.table.columns[field];
             const asBoolean = column?.type === ColumnType.Boolean && ctx.formatAsJson;
-            const asJson = column?.type === ColumnType.Json && ctx.formatAsJson;
+            const jsonColumn = column?.type === ColumnType.Json;
+            const asJson = jsonColumn && ctx.formatAsJson;
             if (asJson) {
               stmt.raw("json");
               stmt.openParenthesis();
@@ -456,6 +460,8 @@ var Formatter = class {
               stmt.add(`, 'true', 'false'))`);
             if (asJson)
               stmt.closeParenthesis();
+            if (jsonColumn && !asJson)
+              stmt.raw("->>'$'");
             return stmt;
         }
       default:
@@ -624,7 +630,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 +653,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);
+}

package/dist/lib/Statement.d.ts

@@ -1,33 +1,33 @@
-import { ParamData } from '../define/Param';
-import { Sanitizer } from './Sanitizer';
-export interface StatementOptions {
-    skipNewlines?: boolean;
-}
-export declare class Statement {
-    sanitizer: Sanitizer;
-    options: StatementOptions;
-    sql: string;
-    paramData: Array<ParamData>;
-    currentIndent: string;
-    constructor(sanitizer: Sanitizer, options?: StatementOptions);
-    space(): this;
-    add(addition: undefined | string): this;
-    addLine(addition: undefined | string): this;
-    indent(): this;
-    dedent(): this;
-    newline(): this;
-    identifier(name: string): this;
-    addIdentifier(name: string): this;
-    value(value: any): this;
-    addValue(value: any): this;
-    param(data: ParamData): this;
-    addParam(data: ParamData): this;
-    raw(query: string): this;
-    openParenthesis(): this;
-    closeParenthesis(): this;
-    call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
-    separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
-    isEmpty(): boolean;
-    params(input?: Record<string, any>): Array<any>;
-    toString(): string;
-}
+import { ParamData } from '../define/Param';
+import { Sanitizer } from './Sanitizer';
+export interface StatementOptions {
+    skipNewlines?: boolean;
+}
+export declare class Statement {
+    sanitizer: Sanitizer;
+    options: StatementOptions;
+    sql: string;
+    paramData: Array<ParamData>;
+    currentIndent: string;
+    constructor(sanitizer: Sanitizer, options?: StatementOptions);
+    space(): this;
+    add(addition: undefined | string): this;
+    addLine(addition: undefined | string): this;
+    indent(): this;
+    dedent(): this;
+    newline(): this;
+    identifier(name: string): this;
+    addIdentifier(name: string): this;
+    value(value: any): this;
+    addValue(value: any): this;
+    param(data: ParamData): this;
+    addParam(data: ParamData): this;
+    raw(query: string): this;
+    openParenthesis(): this;
+    closeParenthesis(): this;
+    call<T>(parts: Array<T>, separator?: string): Generator<T, this | undefined, unknown>;
+    separate<T>(parts: Array<T>, separator?: string): Generator<T, void, unknown>;
+    isEmpty(): boolean;
+    params(input?: Record<string, any>): Array<any>;
+    toString(): string;
+}

package/dist/sqlite/SqliteFormatter.d.ts

@@ -1,11 +1,11 @@
-import { ExprData } from '../define/Expr';
-import { FormatContext, Formatter } from '../lib/Formatter';
-import { Statement } from '../lib/Statement';
-export declare class SqliteFormatter extends Formatter {
-    formatParamValue(paramValue: any): any;
-    escapeValue(value: any): string;
-    escapeIdentifier(input: string): string;
-    escapeString(input: string): string;
-    formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
-    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
-}
+import { ExprData } from '../define/Expr';
+import { FormatContext, Formatter } from '../lib/Formatter';
+import { Statement } from '../lib/Statement';
+export declare class SqliteFormatter extends Formatter {
+    formatParamValue(paramValue: any): any;
+    escapeValue(value: any): string;
+    escapeIdentifier(input: string): string;
+    escapeString(input: string): string;
+    formatAccess(ctx: FormatContext, mkSubject: () => void, field: string): Statement;
+    formatExpr(ctx: FormatContext, expr: ExprData): Statement;
+}