@h3ravel/arquebus 0.2.2 → 0.2.4

package/types/generics.ts

@@ -0,0 +1,71 @@
+import type Model from 'src/model'
+
+export type TGeneric<V = any, K extends string = string> = Record<K, V>
+export type XGeneric<V = TGeneric, T = any> = {
+    [key: string]: T
+} & V
+
+export interface Plugin {
+    (model: Model, config: TGeneric): void
+}
+
+export type Hook =
+    | 'creating' | 'created' | 'updating' | 'updated' | 'saving' | 'saved' | 'deleting' | 'deleted'
+    | 'restoring' | 'restored' | 'trashed' | 'forceDeleted';
+
+export type TFunction<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => TReturn;
+
+export type PrimitiveValue =
+    | string
+    | number
+    | boolean
+    | Date
+    | string[]
+    | number[]
+    | boolean[]
+    | Date[]
+    | null
+    | Buffer;
+
+export type ReturnTypeOfMethod<T, K extends keyof T> = T[K] extends (...args: any[]) => infer R ? R : never;
+
+export type SnakeToCamelCase<S extends string> =
+    S extends `${infer T}_${infer U}` ? `${T}${Capitalize<SnakeToCamelCase<U>>}` : S;
+
+// declare const model: ModelDecorator;
+export type CamelToSnakeCase<S extends string> =
+    S extends `${infer T}${infer U}` ?
+    U extends Uncapitalize<U> ? `${Uncapitalize<T>}${CamelToSnakeCase<U>}` : `${Uncapitalize<T>}_${CamelToSnakeCase<U>}` :
+    S;
+
+export type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K : never;
+}[keyof T];
+
+export type RelationNames<T> = FunctionPropertyNames<T> extends infer R
+    ? R extends `relation${infer P}` ? P extends ('sToData' | 'loaded') ? never : CamelToSnakeCase<P> : never
+    : never;
+
+export type MixinConstructor<T = TGeneric> = new (...args: any[]) => T
+
+// Helper type: combine all mixin instance types into a single intersection
+export type MixinReturn<Base extends MixinConstructor, Mixins extends ((base: any) => any)[]> =
+    Base extends MixinConstructor<infer B>
+    ? IntersectionOfInstances<InstanceTypeOfMixins<Mixins>> & B
+    : never
+
+export type InstanceTypeOfMixins<T extends ((base: any) => any)[]> =
+    T extends [infer Head, ...infer Tail]
+    ? Head extends (base: any) => infer R
+    ? Tail extends ((base: any) => any)[]
+    ? R | InstanceTypeOfMixins<Tail>
+    : R
+    : never
+    : never
+
+export type IntersectionOfInstances<U> =
+    (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never
+
+export interface DeepMixinFunction {
+    <MC extends MixinConstructor, P extends ((base: any) => any)[]> (Base: MC, ...mixins: P): MixinReturn<MC, P>
+}

package/types/modeling.ts

@@ -0,0 +1,190 @@
+import type { AnyQueryBuilder, WithRelationType } from './query-methods'
+import type { Hook, RelationNames, ReturnTypeOfMethod, SnakeToCamelCase, TFunction, TGeneric } from './generics'
+
+import type { IBuilder } from './builder'
+import type { ICollection } from './utils'
+import type Model from 'src/model'
+import type { TBaseConfig } from './container'
+
+export interface Attribute {
+    make (config: { get?: TFunction | null, set?: TFunction | null }): Attribute;
+    get: TFunction | null
+    set: TFunction | null
+    withCaching?: boolean
+    withObjectCaching?: boolean
+}
+
+export interface CastsAttributes {
+    get (): any;
+    set (): void;
+}
+
+export type Relation<M extends Model> = IBuilder<M, any> & {
+}
+
+export interface HasOneOrMany<M extends Model> extends Relation<M> {
+    save (model: M): Promise<M>;
+    saveMany (models: M[] | ICollection<M>): Promise<ICollection<M>>;
+    create (attributes?: any): Promise<M>;
+    createMany (records: any[]): Promise<ICollection<M>>;
+}
+
+export interface HasOne<M extends Model> extends HasOneOrMany<M> {
+    getResults (): Promise<M | null>;
+    withDefault (callback?: TFunction | object): this;
+}
+
+export interface HasMany<M extends Model> extends HasOneOrMany<M> {
+    getResults (): Promise<ICollection<M>>;
+}
+
+export interface BelongsTo<M extends Model> extends Relation<M> {
+    getResults (): Promise<M | null>;
+    withDefault (callback?: TFunction | object): this;
+}
+
+export interface BelongsToMany<M extends Model> extends Relation<M> {
+    getResults (): Promise<ICollection<M>>;
+    withTimestamps (): this;
+    wherePivot (column: any, operator?: any, value?: any, boolean?: string, ...args: any[]): this;
+    wherePivotBetween (column: any, values: any, boolean?: string, not?: boolean): this;
+    orWherePivotBetween (column: any, values: any): this;
+    wherePivotNotBetween (column: any, values: any, boolean?: string): this;
+    orWherePivotNotBetween (column: any, values: any): this;
+    wherePivotIn (column: any, values: any, boolean?: string, not?: boolean): this;
+    orWherePivot (column: any, operator?: any, value?: any): this;
+    orWherePivotIn (column: any, values: any): this;
+    wherePivotNotIn (column: any, values: any, boolean?: string): this;
+    orWherePivotNotIn (column: any, values: any): this;
+    wherePivotNull (column: any, boolean?: string, not?: boolean): this;
+    wherePivotNotNull (column: any, boolean?: string): this;
+    orWherePivotNull (column: any, not?: boolean): this;
+    orWherePivotNotNull (column: any): this;
+    orderByPivot (column: any, direction?: string): this;
+}
+
+export interface IModel {
+    [value: string]: any;
+    attributes: any
+    relations: any
+    exists: boolean
+    primaryKey: string
+    builder?: IBuilder<any, any> | null
+    table: string | null
+    connection?: TBaseConfig['client'] | null
+    keyType: string
+    incrementing: boolean
+    perPage: number
+    with: string | string[] | TGeneric<(...args: any[]) => IBuilder<Model>>
+    withCount: string[]
+    trx: AnyQueryBuilder | null
+    timestamps: boolean
+    dateFormat: string
+    visible: string[]
+    hidden: string[]
+    query<T extends { prototype: unknown }> (this: T, client?: AnyQueryBuilder | null): IBuilder<Model>;
+    on<T extends { prototype: unknown }> (this: T, connection: string | null): IBuilder<Model>;
+    boot (): void;
+    make<T extends IModel> (this: new () => T, attributes?: TGeneric): T;
+    addHook (hook: Hook, callback: TFunction): void;
+    creating (callback: TFunction): void;
+    created (callback: TFunction): void;
+    updating (callback: TFunction): void;
+    updated (callback: TFunction): void;
+    deleting (callback: TFunction): void;
+    deleted (callback: TFunction): void;
+    saving (callback: TFunction): void;
+    saved (callback: TFunction): void;
+    restoring (callback: TFunction): void;
+    restored (callback: TFunction): void;
+    trashed (callback: TFunction): void;
+    forceDeleted (callback: TFunction): void;
+    bootIfNotBooted (): void;
+    initialize (): void;
+    initializePlugins (): void;
+    addPluginInitializer (method: any): void;
+    newInstance (attributes?: TGeneric, exists?: boolean): any;
+    getKey (): string | number | null | undefined;
+    getKeyName (): string;
+    getConnectionName (): string;
+    getConnection (): any;
+    setConnection (connection: TBaseConfig['client'] | null): this;
+    usesUniqueIds (): boolean;
+    uniqueIds (): string[];
+    newUniqueId (): string;
+    setUniqueIds (): void;
+    getKeyType (): string;
+    getIncrementing (): boolean;
+    setIncrementing (value: boolean): this;
+    getTable (): string;
+    setTable (table: string): this;
+    getDates (): string[];
+    getDateFormat (): string;
+    getAttributes (): object;
+    getAttribute (key: string): any;
+    setAttribute (key: string, value: any): this;
+    fill (attributes: any): this;
+    setAppends (appends: string[]): this;
+    append (key: string | string[]): this;
+    getRelation<T extends Model> (relation: string): T | ICollection<T> | null | undefined;
+    setRelation<T extends Model> (relation: string, value: T | ICollection<T> | null): this;
+    unsetRelation (relation: string): this;
+    relationLoaded (relation: string): boolean;
+    makeVisible (attributes: string | string[]): this;
+    makeHidden (attributes: string | string[]): this;
+    newCollection (models?: any[]): ICollection<Model>;
+    load (relations: WithRelationType): Promise<this>;
+    load (...relations: WithRelationType[]): Promise<this>;
+    loadAggregate (relations: WithRelationType, column: any, callback?: any): Promise<this>;
+    loadCount (...relations: WithRelationType[]): Promise<this>;
+    loadMax (relations: WithRelationType, column: string): Promise<this>;
+    loadMin (relations: WithRelationType, column: string): Promise<this>;
+    loadSum (relations: WithRelationType, column: string): Promise<this>;
+    usesTimestamps (): boolean;
+    updateTimestamps (): this;
+    getCreatedAtColumn (): string;
+    getUpdatedAtColumn (): string;
+    getDeletedAtColumn (): string;
+    setCreatedAt (value: string): this;
+    setUpdatedAt (value: string): this;
+    freshTimestamp (): Date;
+    freshTimestampString (): string;
+    fromDateTime (value: Date | number | null): string;
+    useSoftDeletes (): boolean;
+    toData (): any;
+    attributesToData (): any;
+    relationsToData (): any;
+    toJSON (): any;
+    toJson (): string;
+    toString (): string;
+    isDirty (attributes?: string | string[]): boolean;
+    getDirty (): string[];
+    save (options?: any): Promise<boolean>;
+    update (attributes?: any, options?: any): Promise<boolean>;
+    increment (column: string, amount?: number, extra?: any): Promise<boolean>;
+    decrement (column: string, amount?: number, extra?: any): Promise<boolean>;
+    serializeDate (date: any): string;
+    delete (options?: any): Promise<boolean>;
+    softDelete (options?: any): Promise<boolean>;
+    forceDelete (options?: any): Promise<boolean>;
+    restore (options?: any): Promise<boolean>;
+    trashed (): boolean;
+    fresh (): Promise<this>;
+    refresh (): Promise<this | undefined>;
+    push (): Promise<boolean>;
+    is (model: this): boolean;
+    isNot (model: this): boolean;
+    // related(relation: string): Builder<any>;
+    // getRelated<T extends IModel>(relation: string): Promise<this | Collection<T> | null>;
+    related<T extends RelationNames<this>> (relation: T): ReturnTypeOfMethod<
+        this,
+        `relation${Capitalize<SnakeToCamelCase<T>>}`
+    >;
+    getRelated<T extends RelationNames<this>> (relation: T): ReturnTypeOfMethod<
+        ReturnTypeOfMethod<this, `relation${Capitalize<SnakeToCamelCase<T>>}`>, any>//'getResults'>;
+    hasOne<T extends Model> (model: new () => T, foreignKey?: string, localKey?: string): HasOne<T>;
+    hasMany<T extends Model> (model: new () => T, foreignKey?: string, localKey?: string): HasMany<T>;
+    belongsTo<T extends Model> (model: new () => T, foreignKey?: string, ownerKey?: string, relation?: string): BelongsTo<T>;
+    belongsToMany<T extends Model> (model: new () => T, table?: string, foreignPivotKey?: string, relatedPivotKey?: string, parentKey?: string, relatedKey?: string): BelongsToMany<T>;
+}
+export type IPivot = IModel & {}

package/types/query-builder.ts

@@ -0,0 +1,170 @@
+import type { AnyQueryBuilder, GroupByMethod, JoinMethod, JoinRawMethod, OrderByMethod, OrderByRawMethod, RawInterface, SelectMethod, SetOperationsMethod, UnionMethod, WhereBetweenMethod, WhereColumnMethod, WhereExistsMethod, WhereFieldExpressionMethod, WhereInMethod, WhereJsonExpressionMethod, WhereMethod, WhereNullMethod, WhereRawMethod, WhereWrappedMethod } from './query-methods'
+import type { ICollection, IPaginator, IPaginatorParams } from './utils'
+import type { TFunction, TGeneric } from './generics'
+
+import type BModel from 'src/browser/model'
+import type { Knex } from 'knex'
+import type Model from 'src/model'
+
+export interface SchemaBuilder extends Knex.SchemaBuilder {
+    [k: string]: any
+};
+
+interface AsMethod<QB extends AnyQueryBuilder> {
+    (alias: string): QB;
+}
+
+export interface IStatement {
+    grouping: string
+    direction: string
+    type: string
+    value: () => any,
+    not: boolean
+    nulls: boolean
+    bool: 'and' | 'or' | 'not'
+}
+
+export type IConnector<M extends TGeneric = any, R = any> = Knex & Knex.QueryBuilder<M, R>
+
+export interface IQueryBuilder<M extends Model | BModel = Model, R = M[] | M> {
+    // connector: IQueryBuilder<M, R>
+    schema: SchemaBuilder
+    _statements: IStatement[],
+    table (name: string): IQueryBuilder<M, R>
+    select: SelectMethod<this>
+    columns: SelectMethod<this>
+    column: SelectMethod<this>
+    distinct: SelectMethod<this>
+    distinctOn: SelectMethod<this>
+    as: AsMethod<this>
+    asProxy (): IQueryBuilder<M, R>
+    where: WhereMethod<this>
+    andWhere: WhereMethod<this>
+    // orWhere: WhereMethod<this>
+    orWhere (...args: any[]): this
+    whereNot: WhereMethod<this>
+    andWhereNot: WhereMethod<this>
+    orWhereNot: WhereMethod<this>
+
+    whereRaw: WhereRawMethod<this>
+    orWhereRaw: WhereRawMethod<this>
+    andWhereRaw: WhereRawMethod<this>
+
+    whereWrapped: WhereWrappedMethod<this>
+    havingWrapped: WhereWrappedMethod<this>
+
+    whereExists: WhereExistsMethod<this>
+    orWhereExists: WhereExistsMethod<this>
+    whereNotExists: WhereExistsMethod<this>
+    orWhereNotExists: WhereExistsMethod<this>
+
+    whereIn: WhereInMethod<this>
+    orWhereIn: WhereInMethod<this>
+    whereNotIn: WhereInMethod<this>
+    orWhereNotIn: WhereInMethod<this>
+
+    whereBetween: WhereBetweenMethod<this>
+    orWhereBetween: WhereBetweenMethod<this>
+    andWhereBetween: WhereBetweenMethod<this>
+    whereNotBetween: WhereBetweenMethod<this>
+    orWhereNotBetween: WhereBetweenMethod<this>
+    andWhereNotBetween: WhereBetweenMethod<this>
+
+    whereNull: WhereNullMethod<this>
+    orWhereNull: WhereNullMethod<this>
+    whereNotNull: WhereNullMethod<this>
+    orWhereNotNull: WhereNullMethod<this>
+
+    whereColumn: WhereColumnMethod<this>
+    orWhereColumn: WhereColumnMethod<this>
+    andWhereColumn: WhereColumnMethod<this>
+    whereNotColumn: WhereColumnMethod<this>
+    orWhereNotColumn: WhereColumnMethod<this>
+    andWhereNotColumn: WhereColumnMethod<this>
+
+    whereJsonIsArray: WhereFieldExpressionMethod<this>
+    orWhereJsonIsArray: WhereFieldExpressionMethod<this>
+    whereJsonNotArray: WhereFieldExpressionMethod<this>
+    orWhereJsonNotArray: WhereFieldExpressionMethod<this>
+    whereJsonIsObject: WhereFieldExpressionMethod<this>
+    orWhereJsonIsObject: WhereFieldExpressionMethod<this>
+    whereJsonNotObject: WhereFieldExpressionMethod<this>
+    orWhereJsonNotObject: WhereFieldExpressionMethod<this>
+    whereJsonHasAny: WhereJsonExpressionMethod<this>
+    orWhereJsonHasAny: WhereJsonExpressionMethod<this>
+    whereJsonHasAll: WhereJsonExpressionMethod<this>
+    orWhereJsonHasAll: WhereJsonExpressionMethod<this>
+
+    having: WhereMethod<this>
+    andHaving: WhereMethod<this>
+    orHaving: WhereMethod<this>
+
+    havingRaw: WhereRawMethod<this>
+    orHavingRaw: WhereRawMethod<this>
+
+    havingIn: WhereInMethod<this>
+    orHavingIn: WhereInMethod<this>
+    havingNotIn: WhereInMethod<this>
+    orHavingNotIn: WhereInMethod<this>
+
+    havingNull: WhereNullMethod<this>
+    orHavingNull: WhereNullMethod<this>
+    havingNotNull: WhereNullMethod<this>
+    orHavingNotNull: WhereNullMethod<this>
+
+    havingExists: WhereExistsMethod<this>
+    orHavingExists: WhereExistsMethod<this>
+    havingNotExists: WhereExistsMethod<this>
+    orHavingNotExists: WhereExistsMethod<this>
+
+    havingBetween: WhereBetweenMethod<this>
+    orHavingBetween: WhereBetweenMethod<this>
+    havingNotBetween: WhereBetweenMethod<this>
+    orHavingNotBetween: WhereBetweenMethod<this>
+
+    union: UnionMethod<this>
+    unionAll: UnionMethod<this>
+    intersect: SetOperationsMethod<this>
+
+    join: JoinMethod<this>
+    joinRaw: JoinRawMethod<this>
+    innerJoin: JoinMethod<this>
+    leftJoin: JoinMethod<this>
+    leftOuterJoin: JoinMethod<this>
+    rightJoin: JoinMethod<this>
+    rightOuterJoin: JoinMethod<this>
+    outerJoin: JoinMethod<this>
+    fullOuterJoin: JoinMethod<this>
+    crossJoin: JoinMethod<this>
+
+    orderBy: OrderByMethod<this>
+    orderByRaw: OrderByRawMethod<this>
+
+    groupBy: GroupByMethod<this>
+    groupByRaw: RawInterface<this>
+    transaction (callback?: TFunction): Promise<Knex.Transaction> | undefined;
+    destroy (callback: TFunction): Promise<number>;
+    destroy (): Promise<number>;
+    clone (): IQueryBuilder<M, R>;
+    raw: Knex.RawQueryBuilder<TGeneric, M>;
+    get (columns?: string[]): Promise<any>;
+    first (columns?: string[]): Promise<M | null | undefined>;
+    find (key: string | number, columns?: string[]): Promise<M | null | undefined>;
+    insert (attributes: any): Promise<unknown>;
+    update (...attributes: any[]): Promise<number>;
+    delete (): Promise<boolean | number>;
+    exists (): Promise<boolean>;
+    count (column?: string): Promise<number>;
+    min (column: string): Promise<number>;
+    max (column: string): Promise<number>;
+    sum (column: string): Promise<number>;
+    avg (column: string): Promise<number>;
+    skip (count: number): this;
+    take (count: number): this;
+    limit (count: number): this;
+    offset (count: number): this;
+    pluck<X extends Model = any> (column: string): Promise<ICollection<X>>;
+    chunk (count: number, callback: (rows: M[]) => any): Promise<boolean>;
+    forPage (page: number, perPage?: number): this;
+    paginate<F extends IPaginatorParams> (page?: number, perPage?: number): Promise<IPaginator<M, F>>;
+}

package/types/query-methods.ts

@@ -0,0 +1,183 @@
+import type { IBuilder } from './builder'
+import type { IQueryBuilder } from './query-builder'
+import type { Knex } from 'knex'
+import type { Model } from 'src/model'
+import type { PrimitiveValue } from './generics'
+
+type Operator = string;
+type ColumnRef = string | Raw;
+type FieldExpression = string;
+type JsonObjectOrFieldExpression = object | object[] | FieldExpression;
+
+type TableRef<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
+type Selection<QB extends AnyQueryBuilder> = ColumnRef | AnyQueryBuilder | CallbackVoid<QB>;
+type QBOrCallback<QB extends AnyQueryBuilder> = AnyQueryBuilder | CallbackVoid<QB>;
+
+interface CallbackVoid<T> {
+    (this: T, arg: T): void;
+}
+
+export type Raw = Knex.Raw;
+
+export type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
+
+export interface OrderByDescriptor {
+    column: ColumnRef;
+    order?: OrderByDirection;
+}
+
+export type AnyQueryBuilder<M extends Model = any, R = any> = IQueryBuilder<M, R> | IBuilder<M, R>;
+
+export type Expression<T> = T | Raw | AnyQueryBuilder;
+
+export type ColumnRefOrOrderByDescriptor = ColumnRef | OrderByDescriptor;
+
+export interface RawInterface<R> {
+    (sql: string, ...bindings: any[]): R;
+}
+
+export interface BaseSetOperations<QB extends AnyQueryBuilder> {
+    (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB;
+    (callbacksOrBuilders: QBOrCallback<QB>[], wrap?: boolean): QB;
+}
+
+export type JoinRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {}
+
+export type OrderByRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {}
+
+export type WhereRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {}
+
+export interface GroupByMethod<QB extends AnyQueryBuilder> {
+    (...columns: ColumnRef[]): QB;
+    (columns: ColumnRef[]): QB;
+}
+
+export type WithRelationType = {
+    [key: string]: <T extends IBuilder<any>>(builder: T) => T | void;
+} | string | string[];
+
+export interface SetOperationsMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
+    (...callbacksOrBuilders: QBOrCallback<QB>[]): QB;
+}
+
+export interface SelectMethod<QB extends AnyQueryBuilder> {
+    <QBP extends QB> (...columns: Selection<QBP>[]): QB;
+    <QBP extends QB> (columns: Selection<QBP>[]): QB;
+}
+
+export interface WhereMethod<QB extends AnyQueryBuilder> {
+    (col: ColumnRef, op: Operator, expr: Expression<PrimitiveValue>): QB;
+    (col: ColumnRef, expr: Expression<PrimitiveValue>): QB;
+
+    (condition: boolean): QB;
+    (cb: CallbackVoid<QB>): QB;
+    (raw: Raw): QB;
+    <QBA extends AnyQueryBuilder> (qb: QBA): QB;
+
+    (obj: object): QB;
+}
+
+export interface WhereWrappedMethod<QB extends AnyQueryBuilder> {
+    (cb: CallbackVoid<QB>): QB;
+}
+
+export interface WhereFieldExpressionMethod<QB extends AnyQueryBuilder> {
+    (fieldExpression: FieldExpression): QB;
+}
+
+export interface WhereExistsMethod<QB extends AnyQueryBuilder> {
+    (cb: CallbackVoid<QB>): QB;
+    (raw: Raw): QB;
+    <QBA extends AnyQueryBuilder> (qb: QBA): QB;
+}
+
+export interface WhereInMethod<QB extends AnyQueryBuilder> {
+    (col: ColumnRef | ColumnRef[], expr: Expression<PrimitiveValue>[]): QB;
+    (col: ColumnRef | ColumnRef[], cb: CallbackVoid<QB>): QB;
+    (col: ColumnRef | ColumnRef[], qb: AnyQueryBuilder): QB;
+}
+
+export interface WhereBetweenMethod<QB extends AnyQueryBuilder> {
+    (column: ColumnRef, range: [Expression<PrimitiveValue>, Expression<PrimitiveValue>]): QB;
+}
+
+export interface WhereNullMethod<QB extends AnyQueryBuilder> {
+    (column: ColumnRef): QB;
+}
+
+export interface OrderByMethod<QB extends AnyQueryBuilder> {
+    (column: ColumnRef, order?: OrderByDirection): QB;
+    (columns: ColumnRefOrOrderByDescriptor[]): QB;
+}
+
+export interface WhereJsonExpressionMethod<QB extends AnyQueryBuilder> {
+    (fieldExpression: FieldExpression, keys: string | string[]): QB;
+}
+
+export interface WhereColumnMethod<QB extends AnyQueryBuilder> {
+    (col1: ColumnRef, op: Operator, col2: ColumnRef): QB;
+    (col1: ColumnRef, col2: ColumnRef): QB;
+}
+
+export interface JoinMethod<QB extends AnyQueryBuilder> {
+    (table: TableRef<QB>, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, leftCol: ColumnRef, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, cb: CallbackVoid<Knex.JoinClause>): QB;
+    (table: TableRef<QB>, raw: Raw): QB;
+    (raw: Raw): QB;
+}
+
+export interface WhereJsonMethod<QB extends AnyQueryBuilder> {
+    (
+        fieldExpression: FieldExpression,
+        jsonObjectOrFieldExpression: JsonObjectOrFieldExpression
+    ): QB;
+}
+
+export interface UnionMethod<QB extends AnyQueryBuilder> extends BaseSetOperations<QB> {
+    (arg1: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, wrap?: boolean): QB;
+    (arg1: QBOrCallback<QB>, arg2: QBOrCallback<QB>, arg3: QBOrCallback<QB>, wrap?: boolean): QB;
+    (
+        arg1: QBOrCallback<QB>,
+        arg2: QBOrCallback<QB>,
+        arg3: QBOrCallback<QB>,
+        arg4: QBOrCallback<QB>,
+        wrap?: boolean
+    ): QB;
+    (
+        arg1: QBOrCallback<QB>,
+        arg2: QBOrCallback<QB>,
+        arg3: QBOrCallback<QB>,
+        arg4: QBOrCallback<QB>,
+        arg5: QBOrCallback<QB>,
+        wrap?: boolean
+    ): QB;
+    (
+        arg1: QBOrCallback<QB>,
+        arg2: QBOrCallback<QB>,
+        arg3: QBOrCallback<QB>,
+        arg4: QBOrCallback<QB>,
+        arg5: QBOrCallback<QB>,
+        arg6: QBOrCallback<QB>,
+        wrap?: boolean
+    ): QB;
+    (
+        arg1: QBOrCallback<QB>,
+        arg2: QBOrCallback<QB>,
+        arg3: QBOrCallback<QB>,
+        arg4: QBOrCallback<QB>,
+        arg5: QBOrCallback<QB>,
+        arg6: QBOrCallback<QB>,
+        arg7: QBOrCallback<QB>,
+        wrap?: boolean
+    ): QB;
+}
+
+export interface JoinMethod<QB extends AnyQueryBuilder> {
+    (table: TableRef<QB>, leftCol: ColumnRef, op: Operator, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, leftCol: ColumnRef, rightCol: ColumnRef): QB;
+    (table: TableRef<QB>, cb: CallbackVoid<Knex.JoinClause>): QB;
+    (table: TableRef<QB>, raw: Raw): QB;
+    (raw: Raw): QB;
+}

package/types/utils.ts

@@ -0,0 +1,69 @@
+import type BModel from 'src/browser/model'
+import type { Collection as BaseCollection } from 'collect.js'
+import type Collection from 'src/collection'
+import type { IBuilder } from './builder'
+import type { IModel } from './modeling'
+import type Model from 'src/model'
+import type { TGeneric } from './generics'
+
+export interface ICollection<T extends Model | BModel> extends BaseCollection<T> {
+    items?: T[];
+    load (...relations: T[]): Promise<ICollection<T>>;
+    loadAggregate (relations: T | T[], column: string, action?: string | null): Promise<this>;
+    loadCount (relation: T, column: string): Promise<this>;
+    loadMax (relation: T, column: string): Promise<this>;
+    loadMin (relation: T, column: string): Promise<this>;
+    loadSum (relation: T, column: string): Promise<this>;
+    loadAvg (relation: T, column: string): Promise<this>;
+    mapThen (callback: () => void): Promise<any>;
+    modelKeys (): string[] | number[];
+    contains (key: IModel | any, operator?: any, value?: any): boolean;
+    diff (items: ICollection<T> | any[]): ICollection<T>;
+    except (keys: any[]): ICollection<T>;
+    intersect (items: T[]): ICollection<T>;
+    unique (key?: any, strict?: boolean): ICollection<T>;
+    find (key: any, defaultValue?: any): any;
+    fresh (withs?: any[]): Promise<ICollection<T>>;
+    makeVisible (attributes: string | string[]): this;
+    makeHidden (attributes: string | string[]): this;
+    append (attributes: string[]): this;
+    only (keys: null | any[]): this;
+    getDictionary (items?: any[]): TGeneric;
+    toQuery (): IBuilder<T, any>;
+    toData (): any;
+    toJSON (): any;
+    toJson (): string;
+    toString (): string;
+    [key: string]: any;
+    [Symbol.iterator]: () => Iterator<T>;
+}
+
+export interface IPaginatorParams {
+    current_page: number,
+    data: any[],
+    per_page: number,
+    total: number,
+    last_page: number,
+    count: number,
+}
+
+export interface IPaginator<T extends Model | BModel, K extends IPaginatorParams = IPaginatorParams> {
+    formatter?(paginator: IPaginator<any>): any | null
+    setFormatter?(formatter: (paginator: IPaginator<any>) => any | null): void;
+    setItems (items: T[] | Collection<T>): void;
+    hasMorePages (): boolean;
+    get (index: number): T | null;
+    count (): number;
+    items (): Collection<T>;
+    map (callback: (value: T, index: number) => T): Collection<T>;
+    currentPage (): number;
+    perPage (): number;
+    lastPage (): number;
+    firstItem (): number | null;
+    lastItem (): number | null;
+    total (): number;
+    toData<U = K> (): U;
+    toJSON<U = K> (): U;
+    toJson (): string;
+    [Symbol.iterator]?(): { next: () => { value: T; done: boolean } };
+}