adonis.flow.js

// @flow

/* eslint no-redeclare: off */
/* eslint no-use-before-define: off */

declare type adonis$UntypedModules =
  | 'Context/Manager'
  | 'Route'
  | '@adonisjs/fold'
  | 'App/Initializers/Validators/boot'
  | 'App/Initializers/Pg/boot'
  | 'Factory'
  | 'Schema'
  | 'Task'
  | 'Test/Suite';

declare interface adonis$Transaction {
  isGlobal: boolean;
  transaction: adonis$Transaction;

  raw(query: string, values?: any): Promise<any>;
  commit(): Promise<void>;
  rollback(): Promise<void>;
}

declare interface adonis$Mail {
  fake(): void;
  raw(content: string, callback: Function): Promise<void>;
}

declare interface adonis$Validator {
  formatters: { JsonApi: Function };
  rule(rule: string, options?: any): Function;
  extend(key: string, validator: Function): void;
}

declare interface adonis$Config {
  get(key: string): any;
}

declare interface adonis$Hash {
  make(secret: string): Promise<string>;
}

declare interface adonis$Drive {
  disk(diskName: string): Promise<any>;
}

declare interface adonis$Helpers {
  tmpPath(): string;
  databasePath(string): string;
  appRoot(path?: string): string;
  promisify(fn: Function): (...args: any) => Promise<any>;
  resourcesPath(resource: string): string;
}

interface adonis$Algolia {
  indexName: string;

  setSettings(indexSettings?: Object, options?: Object): Promise<Object>;
  getIndex(indexName: string): adonis$Algolia;
  search(searchParams?: Object): Promise<Object>;
  clearIndex(): Promise<void>;
  addObjects(Object[]): Promise<void>;
  addObject(Object): Promise<void>;
  deleteObject(objectId: string): Promise<void>;
}

declare interface adonis$Env {
  load(filePath: string, overwrite?: boolean, encoding?: string): void;
  getEnvPath(): string;
  get(key: string, defaultValue?: any): any;
  set(key: string, value: any): void;
}

declare interface adonis$Scheduler {
  run(): Promise<void>;
}

type adonis$RequestParams = {
  [param: string]: any
};

type adonis$RequestBody = {
  [params: string]: any
};

interface adonis$Request {
  id: string;
  body: adonis$RequestBody;
  post(): adonis$RequestBody;
  get(): adonis$RequestParams;
  all(): Object;
  input(string, ?any): any;
  file(string, ?Object): any;
  only(Array<string>): Object;
  header(string): string;
  headers(): Object;
  raw(): string;
  request: Object;
  ip(): string;
}

interface adonis$Response {
  status(statusCode: number): adonis$Response;
  send(any): void;
  json(any): void;
  redirect(url: string): void;
  response: Object;
}

interface adonis$Jwt {
  type: 'bearer';
  token: string;
  refreshToken: ?string;
}

interface adonis$AuthMiddleware {
  attempt(string, string, ?boolean): Promise<*>;
  generate(adonis$Model<any>, ?boolean): Promise<*>;
  withRefreshToken(): adonis$AuthMiddleware;
  generateForRefreshToken(string): Promise<*>;
  newRefreshToken(): adonis$AuthMiddleware;
  check(): Promise<*>;
  getUser(): Promise<api$CustomerModel>;
  listTokens(): Promise<*>;
  logout(): Promise<*>;
  remember(boolean): adonis$AuthMiddleware;
  authenticator(string): adonis$AuthMiddleware;
  login(adonis$Model<any>): Promise<*>;
  getAuthHeader(): Object;
  revokeTokens(Array<adonis$Jwt>, ?boolean): Promise<*>;
  revokeTokensForUser(adonis$Model<any>, ?Array<string>, ?boolean): Promise<*>;
}

declare interface adonis$HTTPActionParams {
  request: adonis$Request;
  params: adonis$RequestParams;
  response: adonis$Response;
  auth: adonis$AuthMiddleware;
}

interface adonis$Server {
  HTTPServer: any;

  registerGlobal(middleware: string[]): adonis$Server;
  use(middleware: string[]): adonis$Server;
  registerNamed(middleware: { [name: string]: string }): adonis$Server;
  getInstance(): any;
  setInstance(httpInstance: any): void;
  handle(req: any, res: any): void;
  listen(host?: ?string, port?: ?number | ?string, callback?: Function): any;
  close(callback?: Function): void;
}

declare interface adonis$Encryption {
  encrypt(input: string): Buffer;
  decrypt(input: string): string;
}

declare class adonis$Logger {
  [logLevel: 'error' | 'warning' | 'info']: Function;
}

declare type adonis$GraphParams = {
  relations?: string[],
  scopes?: { [key: string]: string[] }
};

declare class adonis$QueryBuilder<T> {
  delete(transaction?: adonis$Transaction): Promise<any>;
  update(Object, transaction?: adonis$Transaction): Promise<any>;

  select(...fields: string[]): adonis$QueryBuilder<T>;
  distinct(rule: any): adonis$QueryBuilder<T>;
  join(table: string, keyA: string, keyB: string): adonis$QueryBuilder<T>;
  joinRaw(sqlQuery: string): adonis$QueryBuilder<T>;
  leftJoin(table: string, keyA: string, keyB: string): adonis$QueryBuilder<T>;
  with(
    relation: string,
    modifier?: (qb: adonis$QueryBuilder<T>) => void
  ): adonis$QueryBuilder<T>;
  where({ [string]: any }): adonis$QueryBuilder<T>;
  where(field: string, value: any): adonis$QueryBuilder<T>;
  where(
    field: string,
    operator: '>' | '<' | '=',
    value: number
  ): adonis$QueryBuilder<T>;
  whereRaw(sqlQuery: string, values?: any): adonis$QueryBuilder<T>;
  whereNull(field: string): adonis$QueryBuilder<T>;
  whereNotNull(field: string): adonis$QueryBuilder<T>;
  whereIn(field: string, any[]): adonis$QueryBuilder<T>;
  whereNot({ [string]: any }): adonis$QueryBuilder<T>;
  whereNot(field: string, comp: string, value: any): adonis$QueryBuilder<T>;
  whereNot(field: string, value: any): adonis$QueryBuilder<T>;
  whereNotIn(field: string, any[]): adonis$QueryBuilder<T>;
  whereHas(
    field: string,
    modifier?: (qb: adonis$QueryBuilder<T>) => any
  ): adonis$QueryBuilder<T>;
  whereDoesntHave(
    field: string,
    modifier?: (qb: adonis$QueryBuilder<T>) => any
  ): adonis$QueryBuilder<T>;
  andWhere({ [string]: any }): adonis$QueryBuilder<T>;
  orderBy(field: string, order?: 'asc' | 'desc'): adonis$QueryBuilder<T>;
  orderByRaw(sqlQuery: string): adonis$QueryBuilder<T>;
  inState(state: string | string[]): adonis$QueryBuilder<T>;
  notInState(state: string | string[]): adonis$QueryBuilder<T>;
  limit(limit: number): adonis$QueryBuilder<T>;
  transacting(transaction: any): adonis$QueryBuilder<T>;
  has(relation: string): adonis$QueryBuilder<T>;
  doesntHave(relation: string): adonis$QueryBuilder<T>;
  graph(params: adonis$GraphParams): adonis$QueryBuilder<T>;

  getCount(): Promise<string>;
  last(): Promise<T>;
  first(): Promise<T>;
  firstOrFail(): Promise<T>;
  findByOrNew(data: { [string]: any }): Promise<T>;
  fetch(): Promise<T & { rows: T[], size: () => number }>;

  paginate(page?: number): Promise<{ pages: { lastPage: number }, rows: T[] }>;
}

declare interface adonis$Database {
  connection(type: string): { _globalTrx: any };
  raw(sqlQuery: string, values?: mixed[]): string & Promise<any>;
  beginTransaction(): Promise<adonis$Transaction>;
  transaction((transaction: adonis$Transaction) => Promise<any>): Promise<any>;
}

type adonis$ModelEvent =
  | 'beforeCreate'
  | 'afterCreate'
  | 'beforeUpdate'
  | 'afterUpdate'
  | 'beforeSave'
  | 'afterSave'
  | 'beforeDelete'
  | 'afterDelete'
  | 'afterFind'
  | 'afterFetch'
  | 'afterFind'
  | 'afterPaginate'
  | 'afterTransaction';

declare class adonis$Model<T> extends adonis$QueryBuilder<T> {
  $transaction?: adonis$Transaction;
  +$relations: { [string]: any };

  $sideLoaded: { [string]: any };
  $attributes: { [string]: any };

  +id: number;
  +isDeleted: boolean;
  updated_at: Date;
  created_at: Date;

  static Serializer: Object;
  static table: string;
  static name: string;

  static boot(): void;
  static addTrait(trait: string, options?: any): void;
  static addHook(
    event: adonis$ModelEvent,
    callback: string | ((model: T, didCommit: boolean) => ?Promise<*>)
  ): any;

  static algoliaSearch(searchParams: {
    params?: Object,
    populate?: boolean | ((sqlQuery: any) => any)
  }): Promise<Object>;

  static syncWithAlgolia(): Promise<void>;
  syncWithAlgolia(): Promise<void>;

  static unsyncWithAlgolia(): Promise<void>;
  unsyncWithAlgolia(): Promise<void>;

  static create(data?: { [string]: any }, transaction?: any): Promise<T>;
  static query(): adonis$QueryBuilder<T>;
  static find(id: number | string): Promise<?T>;
  static findBy(field: string, value: any): Promise<?T>;
  static findOrNew(?Object): Promise<T>;
  static findOrCreate(
    condition: { [field: string]: any },
    data: { [field: string]: any },
    transaction?: adonis$Transaction
  ): Promise<T>;
  static findOrFail(id: number | string): Promise<T>;
  static findByOrFail(field: string, value: any): Promise<T>;
  static first(): Promise<T>;
  static last(): Promise<T>;
  static getCount(): Promise<string>;

  hasOne(model: string): adonis$Model<T>;
  hasMany(model: string, keyA?: string, keyB?: string): adonis$Model<T>;
  manyThrough(model: string, key: string): adonis$Model<T>;
  hasManyPolymorphic(model: string, key: string): adonis$Model<T>;
  belongsTo(model: string, key?: string): adonis$Model<T>;
  belongsToPolymorphic(models: string[], key: string): adonis$Model<T>;
  belongsToMany(model: string, keyA?: string, keyB?: string): adonis$Model<T>;

  create(
    data?: { [string]: any },
    transaction?: adonis$Transaction
  ): Promise<T>;
  associate(
    model: adonis$Model<any>,
    transaction?: adonis$Transaction
  ): Promise<any>;
  merge(data: { [string]: any }): void;
  fill(data: { [string]: any }): void;
  save(
    data?: { [string]: any },
    transaction?: ?adonis$Transaction
  ): Promise<void>;
  save(transaction?: ?adonis$Transaction): Promise<void>;
  saveMany(data?: Object[]): Promise<void>;
  delete(transaction?: adonis$Transaction): Promise<void>;
  reload(): Promise<void>;
  transitionTo(
    state: string,
    options?: Object,
    transaction?: adonis$Transaction
  ): Promise<void>;

  stateMachine(): Promise<void>;
  states(): api$StateModel;
  currentState(): Promise<api$StateModel>;

  files(): api$FileModel;
  attach(file: Buffer, name: string, transaction?: any): Promise<api$FileModel>;
  attach(paymentId: number): Promise<void>;
  attach(parcelId: number, data: any, transaction?: any): Promise<void>;

  toJSON(): $PropertyType<T, '$attributes'> & {
    __meta__: $PropertyType<T, '$sideLoaded'>
  };
}

declare class adonis$BaseExceptionHandler {
  handle(
    error: any,
    { request: adonis$Request, response: adonis$Response }
  ): void;
  repport(
    error: any,
    { request: adonis$Request, response: adonis$Response }
  ): void;
}