@h3ravel/arquebus 0.5.0 → 0.6.0

package/types/query-methods.ts

@@ -4,41 +4,51 @@ 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>;
+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;
+  (this: T, arg: T): void
 }
 
-export type Raw = Knex.Raw;
+export type Raw = Knex.Raw
 
-export type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC';
+export type OrderByDirection = 'asc' | 'desc' | 'ASC' | 'DESC'
 
 export interface OrderByDescriptor {
-    column: ColumnRef;
-    order?: OrderByDirection;
+  column: ColumnRef
+  order?: OrderByDirection
 }
 
-export type AnyQueryBuilder<M extends Model = any, R = any> = IQueryBuilder<M, R> | IBuilder<M, R>;
+export type AnyQueryBuilder<M extends Model = any, R = any> =
+  | IQueryBuilder<M, R>
+  | IBuilder<M, R>
 
-export type Expression<T> = T | Raw | AnyQueryBuilder;
+export type Expression<T> = T | Raw | AnyQueryBuilder
 
-export type ColumnRefOrOrderByDescriptor = ColumnRef | OrderByDescriptor;
+export type ColumnRefOrOrderByDescriptor = ColumnRef | OrderByDescriptor
 
 export interface RawInterface<R> {
-    (sql: string, ...bindings: any[]): R;
+  (sql: string, ...bindings: any[]): R
 }
 
 export interface BaseSetOperations<QB extends AnyQueryBuilder> {
-    (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB;
-    (callbacksOrBuilders: QBOrCallback<QB>[], wrap?: boolean): QB;
+  (callbackOrBuilder: QBOrCallback<QB>, wrap?: boolean): QB
+  (callbacksOrBuilders: QBOrCallback<QB>[], wrap?: boolean): QB
 }
 
 export type JoinRawMethod<QB extends AnyQueryBuilder> = RawInterface<QB> & {}
@@ -48,156 +58,182 @@ 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;
+  (...columns: ColumnRef[]): QB
+  (columns: ColumnRef[]): QB
 }
 
-export type WithRelationType = {
-    [key: string]: <T extends IBuilder<any>>(builder: T) => T | void;
-} | string | string[];
+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 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;
+  <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;
+  (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;
+  (condition: boolean): QB
+  (cb: CallbackVoid<QB>): QB
+  (raw: Raw): QB
+  <QBA extends AnyQueryBuilder>(qb: QBA): QB
 
-    (obj: object): QB;
+  (obj: object): QB
 }
 
 export interface WhereWrappedMethod<QB extends AnyQueryBuilder> {
-    (cb: CallbackVoid<QB>): QB;
+  (cb: CallbackVoid<QB>): QB
 }
 
 export interface WhereFieldExpressionMethod<QB extends AnyQueryBuilder> {
-    (fieldExpression: FieldExpression): QB;
+  (fieldExpression: FieldExpression): QB
 }
 
 export interface WhereExistsMethod<QB extends AnyQueryBuilder> {
-    (cb: CallbackVoid<QB>): QB;
-    (raw: Raw): QB;
-    <QBA extends AnyQueryBuilder> (qb: QBA): QB;
+  (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;
+  (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;
+  (
+    column: ColumnRef,
+    range: [Expression<PrimitiveValue>, Expression<PrimitiveValue>],
+  ): QB
 }
 
 export interface WhereNullMethod<QB extends AnyQueryBuilder> {
-    (column: ColumnRef): QB;
+  (column: ColumnRef): QB
 }
 
 export interface OrderByMethod<QB extends AnyQueryBuilder> {
-    (column: ColumnRef, order?: OrderByDirection): QB;
-    (columns: ColumnRefOrOrderByDescriptor[]): QB;
+  (column: ColumnRef, order?: OrderByDirection): QB
+  (columns: ColumnRefOrOrderByDescriptor[]): QB
 }
 
 export interface WhereJsonExpressionMethod<QB extends AnyQueryBuilder> {
-    (fieldExpression: FieldExpression, keys: string | string[]): QB;
+  (fieldExpression: FieldExpression, keys: string | string[]): QB
 }
 
 export interface ReturningMethod<QB extends AnyQueryBuilder> {
-    (key: FieldExpression | FieldExpression[], options?: { [key: string]: any }): QB;
+  (
+    key: FieldExpression | FieldExpression[],
+    options?: { [key: string]: any },
+  ): QB
 }
 
 export interface FirstOrFailMethod<QB extends AnyQueryBuilder> {
-    (): Promise<QB>;
+  (): Promise<QB>
 }
 
 export interface AddSelectMethod<QB extends AnyQueryBuilder> {
-    (params: string[]): QB;
+  (params: string[]): QB
 }
 
 export interface ForceDeleteMethod {
-    (): Promise<boolean | number>;
+  (): Promise<boolean | number>
 }
 
 export interface RestoreMethod {
-    (): Promise<number>;
+  (): Promise<number>
 }
 
 export interface WhereColumnMethod<QB extends AnyQueryBuilder> {
-    (col1: ColumnRef, op: Operator, col2: ColumnRef): QB;
-    (col1: ColumnRef, col2: ColumnRef): QB;
+  (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;
+  (
+    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;
+  (
+    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;
+  (
+    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

@@ -6,65 +6,73 @@ 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 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,
-    paginated?: boolean
+  current_page: number
+  data: any[]
+  per_page: number
+  total: number
+  last_page: number
+  count: number
+  paginated?: boolean
 }
 
-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 } };
+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 } }
 }