daton/orm/src/builder/Builder.ts

import {escape, EscapedValue, FieldSet, QuerySource} from './types.ts'
import { Select } from './type/Select.ts'
import RawValue from './RawValue.ts'
import {Statement} from './Statement.ts'
import {Update} from './type/Update.ts'
import {Insert} from './type/Insert.ts'
import {Delete} from './type/Delete.ts'
import {Truncate} from "./type/Truncate.ts";

export function raw(value: string) {
    return new RawValue(value)
}

export class IncorrectInterpolationError extends Error {
    constructor(expected: number, received: number) {
        super(`Unable to interpolate arguments into query. Expected ${expected} argument${expected === 1 ? '' : 's'}, but received ${received}.`)
    }
}

export class Builder<T> {
    // create table, alter table, drop table, select

    public select(...fields: FieldSet[]): Select<T> {
        fields = fields.flat()
        const select = new Select<T>()
        return select.fields(...fields)
    }

    public update(target?: QuerySource, alias?: string): Update<T> {
        const update = new Update<T>()
        if ( target ) update.to(target, alias)
        return update
    }

    public delete(target?: QuerySource, alias?: string): Delete<T> {
        const del = new Delete<T>()
        if ( target ) del.from(target, alias)
        return del
    }

    public insert(target?: QuerySource, alias?: string): Insert<T> {
        const insert = new Insert<T>()
        if ( target ) insert.into(target, alias)
        return insert
    }

    public statement(statement: string, ...interpolations: EscapedValue[]): Statement<T> {
        return new Statement<T>(statement, interpolations)
    }

    public truncate(target?: QuerySource, alias?: string): Truncate<T> {
        return new Truncate<T>(target, alias)
    }

    public static raw(value: string) {
        return new RawValue(value)
    }

    public static default() {
        return this.raw('DEFAULT')
    }
}