rado 0.4.8 → 1.0.0-preview.0

package/dist/src/core/Query.d.ts

@@ -0,0 +1,40 @@
+import { internalData, internalQuery, type HasQuery, type HasResolver, type HasTarget } from './Internal.ts';
+import type { Async, QueryMeta, Sync } from './MetaData.ts';
+import type { PreparedStatement, Resolver } from './Resolver.ts';
+import type { Sql } from './Sql.ts';
+export declare class QueryData<Meta extends QueryMeta> {
+    resolver?: Resolver<Meta>;
+    cte?: Array<HasQuery & HasTarget>;
+}
+export declare abstract class Query<Result, Meta extends QueryMeta> implements PromiseLike<Array<Result>> {
+    #private;
+    readonly [internalData]: QueryData<Meta>;
+    abstract [internalQuery]: Sql;
+    constructor(data: QueryData<Meta>);
+    [Symbol.iterator](): Generator<Promise<unknown>, Array<Result>, unknown>;
+    prepare<Inputs extends Record<string, unknown>>(name: string): PreparedQuery<Result, Inputs, Meta>;
+    all(this: Query<Result, Sync>): Array<Result>;
+    all(this: Query<Result, Async>): Promise<Array<Result>>;
+    all(db: HasResolver<Sync> | Resolver<Sync>): Array<Result>;
+    all(db: HasResolver<Async> | Resolver<Async>): Promise<Array<Result>>;
+    get(this: Query<Result, Sync>): Result;
+    get(this: Query<Result, Async>): Promise<Result>;
+    get(db: HasResolver<Sync> | Resolver<Sync>): Result;
+    get(db: HasResolver<Async> | Resolver<Async>): Promise<Result>;
+    run(this: Query<Result, Sync>): void;
+    run(this: Query<Result, Async>): Promise<void>;
+    run(db: HasResolver<Sync> | Resolver<Sync>): void;
+    run(db: HasResolver<Async> | Resolver<Async>): Promise<void>;
+    then<TResult1 = Array<Result>, TResult2 = never>(this: Query<Result, Sync | Async>, onfulfilled?: ((value: Array<Result>) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(this: Query<Result, Async>, onrejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | undefined | null): Promise<Array<Result> | TResult>;
+    finally(this: Query<Result, Async>, onfinally?: (() => void) | undefined | null): Promise<Array<Result>>;
+}
+export interface PreparedQuery<Result, Inputs extends Record<string, unknown>, Meta extends QueryMeta> extends PreparedStatement<Meta> {
+    all(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): Array<Result>;
+    all(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<Array<Result>>;
+    get(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): Result;
+    get(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<Result>;
+    run(this: PreparedQuery<Result, Inputs, Sync>, inputs?: Inputs): void;
+    run(this: PreparedQuery<Result, Inputs, Async>, inputs?: Inputs): Promise<void>;
+    execute(inputs?: Inputs): Promise<Array<Result>>;
+}

package/dist/src/core/Resolver.d.ts

@@ -0,0 +1,23 @@
+import type { Dialect } from './Dialect.ts';
+import type { Driver, Statement } from './Driver.ts';
+import type { Emitter } from './Emitter.ts';
+import { type HasQuery } from './Internal.ts';
+import type { QueryMeta } from './MetaData.ts';
+export declare class Resolver<Meta extends QueryMeta = QueryMeta> {
+    #private;
+    private brand;
+    constructor(driver: Driver, dialect: Dialect);
+    prepare(query: HasQuery, name: string): PreparedStatement<Meta>;
+}
+type RowMapper = ((values: Array<unknown>) => unknown) | undefined;
+export declare class PreparedStatement<Meta extends QueryMeta> {
+    #private;
+    private brand;
+    constructor(emitter: Emitter, stmt: Statement, mapRow: RowMapper);
+    all(inputs?: Record<string, unknown>): Array<unknown> | Promise<Array<unknown>>;
+    get(inputs?: Record<string, unknown>): unknown | Promise<unknown>;
+    run(inputs?: Record<string, unknown>): unknown;
+    execute(inputs?: Record<string, unknown>): Promise<unknown>;
+    free(): void;
+}
+export {};

package/dist/src/core/Schema.d.ts

@@ -0,0 +1,4 @@
+import { type Table, type TableConfig, type TableDefinition } from './Table.ts';
+export declare function schema<SchemaName extends string>(schemaName: SchemaName): {
+    table<Definition extends TableDefinition, TableName extends string>(tableName: TableName, columns: Definition, config?: ((self: Table<Definition>) => TableConfig<`${SchemaName}.${TableName}`>) | undefined): Table<Definition, `${SchemaName}.${TableName}`>;
+};

package/dist/src/core/Selection.d.ts

@@ -0,0 +1,27 @@
+import { internalSql, type HasSql, type HasTable } from './Internal.ts';
+import { type Sql } from './Sql.ts';
+import type { Table, TableRow } from './Table.ts';
+import type { Expand } from './Types.ts';
+declare const nullable: unique symbol;
+export interface SelectionRecord extends Record<string, SelectionInput> {
+}
+export type IsNullable = {
+    [nullable]: true;
+};
+export type MakeNullable<T> = Expand<{
+    [K in keyof T]: T[K] & IsNullable;
+}>;
+export type SelectionInput = HasSql | HasTable | SelectionRecord;
+export type RowOfRecord<Input> = Expand<{
+    [Key in keyof Input as Key extends string ? Key : never]: SelectionRow<Input[Key]>;
+}>;
+export type SelectionRow<Input> = Input extends HasSql<infer Value> ? Value : Input extends IsNullable ? RowOfRecord<Input> | null : Input extends SelectionRecord ? RowOfRecord<Input> : Input extends Table<infer Definition> ? TableRow<Definition> : never;
+export declare class Selection implements HasSql {
+    #private;
+    constructor(input: SelectionInput, nullable: Set<string>);
+    makeVirtual(name: string): SelectionRecord | HasSql<unknown> | HasTable<import("./Table.ts").TableDefinition, string>;
+    mapRow: (values: Array<unknown>) => unknown;
+    get [internalSql](): Sql<unknown>;
+}
+export declare function selection(input: SelectionInput, nullable?: Set<string>): Selection;
+export {};

package/dist/src/core/Sql.d.ts

@@ -0,0 +1,49 @@
+import type { Emitter } from './Emitter.ts';
+import { internalSql, type HasSql } from './Internal.ts';
+import type { FieldData } from './expr/Field.ts';
+type EmitMethods = {
+    [K in keyof Emitter as K extends `emit${string}` ? K : never]: Emitter[K];
+};
+declare class Chunk<Type = keyof EmitMethods, Inner = unknown> {
+    type: Type;
+    inner: Inner;
+    constructor(type: Type, inner: Inner);
+}
+export type Decoder<T> = ((value: unknown) => T) | {
+    mapFromDriverValue?(value: unknown): T;
+};
+export declare class Sql<Value = unknown> implements HasSql<Value> {
+    #private;
+    private brand;
+    alias?: string;
+    mapFromDriverValue?: (input: unknown) => Value;
+    readonly [internalSql]: this;
+    constructor(chunks?: Array<Chunk>);
+    as(name: string): Sql<Value>;
+    mapWith<T = Value>(decoder: Decoder<T>): Sql<T>;
+    chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql<Value>;
+    unsafe(sql: string): Sql<Value>;
+    field(field: FieldData): Sql<Value>;
+    add(sql: HasSql): Sql<Value>;
+    value(value: unknown): Sql<Value>;
+    inline(value: unknown): Sql<Value>;
+    jsonPath(path: Array<string | number>): Sql<Value>;
+    placeholder(name: string): Sql<Value>;
+    identifier(identifier: string): Sql<Value>;
+    inlineFields(withTableName: boolean): Sql<Value>;
+    emit(emitter: Emitter): void;
+}
+export declare function sql<T>(strings: TemplateStringsArray, ...inner: Array<HasSql>): Sql<T>;
+export declare namespace sql {
+    function empty<T>(): Sql<T>;
+    function unsafe<T>(directSql: string): Sql<T>;
+    function value<T>(value: T): Sql<T>;
+    function inline<T>(value: T): Sql<T>;
+    function placeholder<T>(name: string): Sql<T>;
+    function identifier<T>(identifier: string): Sql<T>;
+    function field<T>(field: FieldData): Sql<T>;
+    function chunk<Type extends keyof EmitMethods>(type: Type, inner: Parameters<EmitMethods[Type]>[0]): Sql;
+    function query(ast: Record<string, HasSql | undefined>): Sql;
+    function join<T>(items: Array<Sql | HasSql | undefined | false>, separator?: Sql): Sql<T>;
+}
+export {};

package/dist/src/core/Table.d.ts

@@ -0,0 +1,56 @@
+import type { Column, JsonColumn, RequiredColumn } from './Column.ts';
+import type { ForeignKeyConstraint, PrimaryKeyConstraint, UniqueConstraint } from './Constraint.ts';
+import type { Index } from './Index.ts';
+import { type HasSql, type HasTable, type HasTarget } from './Internal.ts';
+import { type Sql } from './Sql.ts';
+import { type JsonExpr } from './expr/Conditions.ts';
+import { Field } from './expr/Field.ts';
+import type { Input } from './expr/Input.ts';
+export type TableDefinition = {
+    [name: string]: Column;
+};
+declare class TableData {
+    name: string;
+    alias?: string;
+    schemaName?: string;
+    columns: TableDefinition;
+    config?: TableConfig;
+}
+export declare class TableApi<Definition extends TableDefinition = TableDefinition, Name extends string = string> extends TableData {
+    private brand;
+    get aliased(): string;
+    target(): Sql;
+    createDefinition(): Sql;
+    listColumns(): Sql;
+    fields(): Record<string, HasSql>;
+}
+export type Table<Definition extends TableDefinition = TableDefinition, Name extends string = string> = TableFields<Definition, Name> & HasTable<Definition, Name> & HasTarget;
+export type TableFields<Definition extends TableDefinition, TableName extends string = string> = {
+    [K in keyof Definition]: Definition[K] extends JsonColumn<infer T> ? JsonExpr<T> : Definition[K] extends Column<infer T> ? Field<T, TableName> : never;
+};
+export type TableRow<Definition extends TableDefinition> = {
+    [K in keyof Definition]: Definition[K] extends Column<infer T> ? T : never;
+} & {};
+type IsReq<Col> = Col extends RequiredColumn ? true : false;
+type Required<D> = {
+    [K in keyof D as true extends IsReq<D[K]> ? K : never]: D[K];
+};
+type Optional<D> = {
+    [K in keyof D as false extends IsReq<D[K]> ? K : never]: D[K];
+};
+type RequiredInput<D> = {
+    readonly [K in keyof Required<D>]: D[K] extends Column<infer V> ? Input<V> : never;
+};
+type OptionalInput<D> = {
+    readonly [K in keyof Optional<D>]?: D[K] extends Column<infer V> ? Input<V> : never;
+};
+export type TableInsert<Definition extends TableDefinition> = RequiredInput<Definition> & OptionalInput<Definition>;
+export type TableUpdate<Definition extends TableDefinition> = {
+    readonly [K in keyof Definition]?: Definition[K] extends Column<infer T> ? Input<T> : never;
+};
+export type TableConfigSetting<Name extends string> = UniqueConstraint<Name> | PrimaryKeyConstraint<Name> | ForeignKeyConstraint<Name> | Index<Name>;
+export interface TableConfig<Name extends string = string> extends Record<string, TableConfigSetting<Name>> {
+}
+export declare function table<Definition extends TableDefinition, Name extends string>(name: Name, columns: Definition, config?: (self: Table<Definition, Name>) => TableConfig<Name>, schemaName?: string): Table<Definition, Name>;
+export declare function alias<Definition extends TableDefinition, Alias extends string>(table: Table<Definition>, alias: Alias): Table<Definition, Alias>;
+export {};

package/dist/src/core/Types.d.ts

@@ -0,0 +1,3 @@
+export type Expand<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/src/core/Virtual.d.ts

@@ -0,0 +1,2 @@
+import type { SelectionInput } from './Selection.ts';
+export declare function virtual<Input extends SelectionInput>(alias: string, source?: Input): Input;

package/dist/src/core/expr/Aggregate.d.ts

@@ -0,0 +1,10 @@
+import { type HasSql } from '../Internal.ts';
+import { type Sql } from '../Sql.ts';
+export declare function count(input?: HasSql): Sql<number>;
+export declare function countDistinct(input: HasSql): Sql<number>;
+export declare function avg(input: HasSql): Sql<string | null>;
+export declare function avgDistinct(input: HasSql): Sql<string | null>;
+export declare function sum(input: HasSql): HasSql<string | null>;
+export declare function sumDistinct(input: HasSql): HasSql<string | null>;
+export declare function max<T>(input: HasSql<T>): Sql<T>;
+export declare function min<T>(input: HasSql<T>): Sql<T>;

package/dist/src/core/expr/Conditions.d.ts

@@ -0,0 +1,40 @@
+import type { HasSql } from '../Internal.ts';
+import { type Sql } from '../Sql.ts';
+import { type Input } from './Input.ts';
+export declare function eq<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function ne<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function and(...conditions: Array<Input<boolean>>): HasSql<boolean>;
+export declare function or(...conditions: Array<Input<boolean>>): HasSql<boolean>;
+export declare function not(condition: Input): HasSql<boolean>;
+export declare function gt<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function gte<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function lt<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function lte<T>(left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function inArray<T>(left: Input<T>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function notInArray<T>(left: Input<T>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function isNull(value: Input): HasSql<boolean>;
+export declare function isNotNull(value: Input): HasSql<boolean>;
+export declare function between<T>(value: Input<T>, left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function notBetween<T>(value: Input<T>, left: Input<T>, right: Input<T>): HasSql<boolean>;
+export declare function like(left: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function notLike(value: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function ilike(value: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function notILike(value: Input<string>, pattern: Input<string>): HasSql<boolean>;
+export declare function arrayContains<T>(left: Input<Array<T>>, right: Input<T>): HasSql<boolean>;
+export declare function arrayContained<T>(left: Input<T>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function arrayOverlaps<T>(left: Input<Array<T>>, right: Input<Array<T>>): HasSql<boolean>;
+export declare function asc<T>(input: HasSql<T>): Sql;
+export declare function desc<T>(input: HasSql<T>): Sql;
+export declare function distinct<T>(input: HasSql<T>): Sql;
+export interface JsonArrayHasSql<Value> extends HasSql<Value> {
+    [index: number]: JsonExpr<Value>;
+}
+export type JsonRecordHasSql<Row> = HasSql<Row> & {
+    [K in keyof Row]: JsonExpr<Row[K]>;
+};
+type Nullable<T> = {
+    [P in keyof T]: T[P] | null;
+};
+export type JsonExpr<Value> = [NonNullable<Value>] extends [Array<infer V>] ? JsonArrayHasSql<null extends Value ? V | null : V> : [NonNullable<Value>] extends [object] ? JsonRecordHasSql<null extends Value ? Nullable<Value> : Value> : HasSql<Value>;
+export declare function jsonExpr<Value>(e: HasSql<Value>): JsonExpr<Value>;
+export {};

package/dist/src/core/expr/Field.d.ts

@@ -0,0 +1,14 @@
+import { internalField, internalSql, type HasSql } from '../Internal.ts';
+import { type Sql } from '../Sql.ts';
+export interface FieldData {
+    targetName: string;
+    fieldName: string;
+}
+export declare class Field<Value = unknown, Table extends string = string> implements HasSql<Value> {
+    private brand;
+    readonly [internalField]: FieldData;
+    readonly [internalSql]: Sql<Value>;
+    constructor(targetName: string, fieldName: string, options?: {
+        mapFromDriverValue?(value: unknown): Value;
+    });
+}

package/dist/src/core/expr/Functions.d.ts

@@ -0,0 +1,6 @@
+import { type Sql } from '../Sql.ts';
+import { type Input } from './Input.ts';
+export declare const Functions: Functions;
+export type Functions = {
+    [key: string]: (...args: Array<Input<any>>) => Sql<any>;
+};

package/dist/src/core/expr/Input.d.ts

@@ -0,0 +1,3 @@
+import { type HasSql } from '../Internal.ts';
+export type Input<T = unknown> = HasSql<T> | T;
+export declare function input<T>(value: Input<T>): HasSql<T>;

package/dist/src/core/query/CreateTable.d.ts

@@ -0,0 +1,13 @@
+import { internalData, internalQuery, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, type QueryData } from '../Query.ts';
+export interface CreateData<Meta extends QueryMeta> extends QueryData<Meta> {
+    table: HasTable;
+    ifNotExists?: boolean;
+}
+export declare class Create<Meta extends QueryMeta = QueryMeta> extends Query<void, Meta> {
+    readonly [internalData]: CreateData<Meta>;
+    constructor(data: CreateData<Meta>);
+    ifNotExists(): Create<Meta>;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}

package/dist/src/core/query/Delete.d.ts

@@ -0,0 +1,19 @@
+import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.ts';
+export declare class DeleteData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
+    from: HasTable;
+    where?: HasSql;
+    returning?: Selection;
+}
+export declare class Delete<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
+    readonly [internalData]: DeleteData<Meta>;
+    readonly [internalSelection]?: Selection;
+    constructor(data: DeleteData<Meta>);
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+export declare class DeleteFrom<Meta extends QueryMeta> extends Delete<void, Meta> {
+    where(condition: HasSql<boolean>): DeleteFrom<Meta>;
+    returning<Input extends SelectionInput>(returning: Input): Delete<SelectionRow<Input>, Meta>;
+}

package/dist/src/core/query/DropTable.d.ts

@@ -0,0 +1,13 @@
+import { internalData, internalQuery, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, type QueryData } from '../Query.ts';
+export interface DropData<Meta extends QueryMeta> extends QueryData<Meta> {
+    table: HasTable;
+    ifExists?: boolean;
+}
+export declare class Drop<Meta extends QueryMeta = QueryMeta> extends Query<void, Meta> {
+    readonly [internalData]: DropData<Meta>;
+    constructor(data: DropData<Meta>);
+    ifExists(): Drop<Meta>;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}

package/dist/src/core/query/Insert.d.ts

@@ -0,0 +1,43 @@
+import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.ts';
+import type { IsPostgres, QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.ts';
+import type { TableDefinition, TableInsert, TableRow, TableUpdate } from '../Table.ts';
+declare class InsertIntoData<Meta extends QueryMeta> extends QueryData<Meta> {
+    into: HasTable;
+    values?: HasSql;
+}
+export declare class InsertData<Meta extends QueryMeta> extends InsertIntoData<Meta> {
+    returning?: Selection;
+    onConflict?: HasSql;
+}
+export declare class Insert<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
+    readonly [internalData]: InsertData<Meta>;
+    readonly [internalSelection]?: Selection;
+    constructor(data: InsertData<Meta>);
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+declare class InsertCanReturn<Definition extends TableDefinition, Meta extends QueryMeta> extends Insert<void, Meta> {
+    returning(): Insert<TableRow<Definition>, Meta>;
+    returning<Input extends SelectionInput>(returning: Input): Insert<SelectionRow<Input>, Meta>;
+}
+export interface OnConflict {
+    target: HasSql | Array<HasSql>;
+    targetWhere?: HasSql<boolean>;
+}
+export interface OnConflictUpdate<Definition extends TableDefinition> extends OnConflict {
+    set: TableUpdate<Definition>;
+    setWhere?: HasSql<boolean>;
+}
+declare class InsertCanConflict<Definition extends TableDefinition, Meta extends QueryMeta> extends InsertCanReturn<Definition, Meta> {
+    #private;
+    onConflictDoNothing(this: InsertCanConflict<Definition, IsPostgres>, onConflict?: OnConflict): InsertCanReturn<Definition, Meta>;
+    onConflictDoUpdate(this: InsertCanConflict<Definition, IsPostgres>, onConflict: OnConflictUpdate<Definition>): InsertCanReturn<Definition, Meta>;
+}
+export declare class InsertInto<Definition extends TableDefinition, Meta extends QueryMeta> {
+    [internalData]: InsertData<Meta>;
+    constructor(data: InsertData<Meta>);
+    values(value: TableInsert<Definition>): InsertCanConflict<Definition, Meta>;
+    values(values: Array<TableInsert<Definition>>): InsertCanConflict<Definition, Meta>;
+}
+export {};

package/dist/src/core/query/Select.d.ts

@@ -0,0 +1,93 @@
+import { internalData, internalQuery, internalSelection, type HasSelection, type HasSql, type HasTable, type HasTarget } from '../Internal.ts';
+import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type IsNullable, type MakeNullable, type SelectionInput, type SelectionRecord, type SelectionRow } from '../Selection.ts';
+import type { Table, TableDefinition, TableFields } from '../Table.ts';
+import type { Expand } from '../Types.ts';
+import type { Field } from '../expr/Field.ts';
+import { type Input as UserInput } from '../expr/Input.ts';
+import { Union } from './Union.ts';
+export type SelectionType = 'selection' | 'allFrom' | 'joinTables';
+export declare class SelectData<Meta extends QueryMeta> extends QueryData<Meta> {
+    select: {
+        type: SelectionType;
+        tables: Array<string>;
+        nullable: Array<string>;
+        input?: SelectionInput;
+    };
+    distinct?: boolean;
+    distinctOn?: Array<HasSql>;
+    from?: HasSql;
+    subject?: HasSql;
+    where?: HasSql;
+    groupBy?: HasSql;
+    having?: HasSql;
+    orderBy?: HasSql;
+    limit?: HasSql;
+    offset?: HasSql;
+}
+export declare class Select<Input, Meta extends QueryMeta = QueryMeta> extends Query<SelectionRow<Input>, Meta> implements HasSelection, SelectBase<Input, Meta> {
+    #private;
+    readonly [internalData]: SelectData<Meta>;
+    constructor(data: SelectData<Meta>);
+    as(alias: string): SubQuery<Input>;
+    from(target: HasTarget): Select<Input, Meta>;
+    leftJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    rightJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    innerJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    fullJoin(right: HasTable, on: HasSql<boolean>): Select<Input, Meta>;
+    where(where: HasSql<boolean>): Select<Input, Meta>;
+    groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    having(having: HasSql<boolean>): Select<Input, Meta>;
+    orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    limit(limit: UserInput<number>): Select<Input, Meta>;
+    offset(offset: UserInput<number>): Select<Input, Meta>;
+    union(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    unionAll(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersect(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersectAll(this: SelectBase<Input, IsPostgres | IsMysql>, right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    except(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    exceptAll(right: SelectBase<Input, IsPostgres | IsMysql>): Union<Input, Meta>;
+    get [internalSelection](): import("../Selection.ts").Selection;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+export type SubQuery<Input> = Input & HasTarget;
+export interface SelectBase<Input, Meta extends QueryMeta = QueryMeta> extends Query<SelectionRow<Input>, Meta>, HasSelection {
+    where(where: HasSql<boolean>): Select<Input, Meta>;
+    groupBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    having(having: HasSql<boolean>): Select<Input, Meta>;
+    orderBy(...exprs: Array<HasSql>): Select<Input, Meta>;
+    limit(limit: UserInput<number>): Select<Input, Meta>;
+    offset(offset: UserInput<number>): Select<Input, Meta>;
+    union(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    unionAll(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersect(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    intersectAll(this: SelectBase<Input, IsPostgres | IsMysql>, right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    except(right: SelectBase<Input, Meta>): Union<Input, Meta>;
+    exceptAll(right: SelectBase<Input, IsPostgres | IsMysql>): Union<Input, Meta>;
+    as(name: string): SubQuery<Input>;
+}
+export interface WithoutSelection<Meta extends QueryMeta> {
+    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): AllFrom<TableFields<Definition>, Meta, Record<Name, TableFields<Definition>>>;
+    from<Input>(from: SubQuery<Input>): SelectionFrom<Input, Meta>;
+}
+export interface WithSelection<Input, Meta extends QueryMeta> {
+    from<Definition extends TableDefinition, Name extends string>(from: Table<Definition, Name>): SelectionFrom<Input, Meta>;
+    from(from: SubQuery<unknown>): SelectionFrom<Input, Meta>;
+}
+export interface AllFrom<Input, Meta extends QueryMeta, Tables = Input> extends SelectBase<Input, Meta> {
+    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & Record<Name, TableFields<Definition>>>, Meta>;
+    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<Tables & Record<Name, TableFields<Definition>>>, Meta>;
+    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): AllFrom<Expand<MakeNullable<Tables> & MakeNullable<Record<Name, TableFields<Definition>>>>, Meta>;
+}
+type MarkFieldsAsNullable<Input, TableName extends string> = Expand<{
+    [K in keyof Input]: Input[K] extends Field<infer T, TableName> ? HasSql<T | null> : Input[K] extends Table<infer Definition, TableName> ? TableFields<Definition> & IsNullable : Input[K] extends Record<string, Field<unknown, TableName> | HasSql<unknown>> ? Input[K] & IsNullable : Input[K] extends SelectionRecord ? MarkFieldsAsNullable<Input[K], TableName> : Input[K];
+}>;
+export interface SelectionFrom<Input, Meta extends QueryMeta> extends SelectBase<Input, Meta> {
+    leftJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<MarkFieldsAsNullable<Input, Name>, Meta>;
+    rightJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    innerJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+    fullJoin<Definition extends TableDefinition, Name extends string>(right: Table<Definition, Name>, on: HasSql<boolean>): SelectionFrom<Input, Meta>;
+}
+export {};

package/dist/src/core/query/Union.d.ts

@@ -0,0 +1,27 @@
+import { internalData, internalQuery, internalSelection, type HasQuery, type HasSelection, type HasSql } from '../Internal.ts';
+import type { IsMysql, IsPostgres, QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import type { Selection } from '../Selection.ts';
+import type { SelectBase } from './Select.ts';
+export declare class UnionData<Meta extends QueryMeta> extends QueryData<Meta> {
+    selection: Selection;
+    left: HasQuery;
+    operator: HasSql;
+    right: HasQuery;
+}
+export declare class Union<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> implements HasSelection {
+    readonly [internalData]: UnionData<Meta>;
+    readonly [internalSelection]: Selection;
+    constructor(data: UnionData<Meta>);
+    union(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    unionAll(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    intersect(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    except(right: SelectBase<Result, Meta>): Union<Result, Meta>;
+    get [internalQuery](): import("../Sql.ts").Sql<unknown>;
+}
+export declare function union<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function unionAll<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function intersect<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function intersectAll<Result, Meta extends IsPostgres | IsMysql>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function except<Result, Meta extends QueryMeta>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;
+export declare function exceptAll<Result, Meta extends IsPostgres | IsMysql>(left: SelectBase<Result, Meta>, right: SelectBase<Result, Meta>): Union<Result, Meta>;

package/dist/src/core/query/Update.d.ts

@@ -0,0 +1,23 @@
+import { internalData, internalQuery, internalSelection, type HasSql, type HasTable } from '../Internal.ts';
+import type { QueryMeta } from '../MetaData.ts';
+import { Query, QueryData } from '../Query.ts';
+import { type Selection, type SelectionInput, type SelectionRow } from '../Selection.ts';
+import { type Sql } from '../Sql.ts';
+import type { TableDefinition, TableUpdate } from '../Table.ts';
+export declare class UpdateData<Meta extends QueryMeta = QueryMeta> extends QueryData<Meta> {
+    table: HasTable;
+    set?: HasSql;
+    where?: HasSql;
+    returning?: Selection;
+}
+export declare class Update<Result, Meta extends QueryMeta = QueryMeta> extends Query<Result, Meta> {
+    readonly [internalData]: UpdateData<Meta>;
+    readonly [internalSelection]?: Selection;
+    constructor(data: UpdateData<Meta>);
+    get [internalQuery](): Sql;
+}
+export declare class UpdateTable<Definition extends TableDefinition, Meta extends QueryMeta> extends Update<void, Meta> {
+    set(values: TableUpdate<Definition>): UpdateTable<Definition, Meta>;
+    where(where: HasSql<boolean>): UpdateTable<Definition, Meta>;
+    returning<Input extends SelectionInput>(returning: Input): Update<SelectionRow<Input>, Meta>;
+}

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

@@ -0,0 +1,3 @@
+import type { Database as Client } from 'better-sqlite3';
+import { SyncDatabase } from '../core/Database.ts';
+export declare function connect(db: Client): SyncDatabase<"sqlite">;

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

@@ -0,0 +1,4 @@
+/// <reference types="bun-types" />
+import type { Database as Client } from 'bun:sqlite';
+import { SyncDatabase } from '../core/Database.ts';
+export declare function connect(db: Client): SyncDatabase<"sqlite">;

package/dist/src/driver/pg.d.ts

@@ -0,0 +1,25 @@
+import pg, { type Client, type PoolClient } from 'pg';
+import { AsyncDatabase, type TransactionOptions } from '../core/Database.ts';
+import type { AsyncDriver, AsyncStatement } from '../core/Driver.ts';
+type Queryable = Client | pg.Pool | PoolClient;
+declare class PreparedStatement implements AsyncStatement {
+    private client;
+    private sql;
+    private name?;
+    constructor(client: Queryable, sql: string, name?: string | undefined);
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object>;
+    values(params: Array<unknown>): Promise<any[][]>;
+    free(): void;
+}
+export declare class PgDriver implements AsyncDriver {
+    private client;
+    constructor(client: Queryable);
+    exec(query: string): Promise<void>;
+    prepare(sql: string, name: string): PreparedStatement;
+    close(): Promise<void>;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres'], depth: number): Promise<T>;
+}
+export declare function connect(client: Queryable): AsyncDatabase<"postgres">;
+export {};

package/dist/src/driver/pglite.d.ts

@@ -0,0 +1,24 @@
+import type { PGlite, Transaction } from '@electric-sql/pglite';
+import type { AsyncDriver, AsyncStatement } from '../core/Driver.ts';
+import { AsyncDatabase, type TransactionOptions } from '../index.ts';
+type Queryable = PGlite | Transaction;
+declare class PreparedStatement implements AsyncStatement {
+    private client;
+    private sql;
+    constructor(client: Queryable, sql: string);
+    all(params: Array<unknown>): Promise<Array<object>>;
+    run(params: Array<unknown>): Promise<void>;
+    get(params: Array<unknown>): Promise<object>;
+    values(params: Array<unknown>): Promise<unknown[][]>;
+    free(): void;
+}
+export declare class PGliteDriver implements AsyncDriver {
+    private client;
+    constructor(client: Queryable);
+    exec(query: string): Promise<void>;
+    close(): Promise<void>;
+    prepare(sql: string): PreparedStatement;
+    transaction<T>(run: (inner: AsyncDriver) => Promise<T>, options: TransactionOptions['postgres']): Promise<T>;
+}
+export declare function connect(db: PGlite): AsyncDatabase<"postgres">;
+export {};

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

@@ -0,0 +1,3 @@
+import type { Database as Client } from 'sql.js';
+import { SyncDatabase } from '../core/Database.ts';
+export declare function connect(db: Client): SyncDatabase<import("../core/MetaData.ts").QueryDialect>;

package/dist/src/index.d.ts

@@ -0,0 +1,16 @@
+export * from './core/Column.ts';
+export * from './core/Constraint.ts';
+export * from './core/Database.ts';
+export * from './core/Driver.ts';
+export * from './core/Index.ts';
+export * from './core/Query.ts';
+export * from './core/Selection.ts';
+export * from './core/Sql.ts';
+export * from './core/Table.ts';
+export * from './core/expr/Conditions.ts';
+export * from './core/query/CreateTable.ts';
+export * from './core/query/Delete.ts';
+export * from './core/query/Insert.ts';
+export * from './core/query/Select.ts';
+export * from './core/query/Union.ts';
+export * from './core/query/Update.ts';

package/dist/src/migrate/Scan.d.ts

@@ -0,0 +1 @@
+export {};