Class NominaTiposJornadas

$attributes

$columns

$dirty

$extras

$isDeleted

$isDirty

$isLocal

$isNew

$isPersisted

Optional$options

$original

$preloaded

Optional$primaryKeyValue

$sideloaded

Optional$trx

load

loadAggregate

loadCount

loadOnce

preload

Static$adapter

Static$columnsDefinitions

Static$computedDefinitions

Static$hooks

Static$keys

Static$relationsDefinitions

Static Readonlybooted

StaticnamingStrategy

StaticprimaryKey

StaticselfAssignPrimaryKey

Statictransaction

$consumeAdapterResult

• $consumeAdapterResult(
      adapterResult: ModelObject,
      sideloadAttributes?: ModelObject,
  ): void

  Consume the adapter result and hydrate the model

  Parameters

  • adapterResult: ModelObject
  • OptionalsideloadAttributes: ModelObject

  Returns void

$getAttribute

• $getAttribute(key: string): any

  Parameters

  • key: string

  Returns any

$getAttributeFromCache

• $getAttributeFromCache(key: string, callback: (value: any) => any): any

  Parameters

  • key: string
  • callback: (value: any) => any

  Returns any

$getQueryFor

• $getQueryFor(
      action: "insert",
      client: QueryClientContract,
  ): InsertQueryBuilderContract<unknown[]>

  Gives an option to the end user to define constraints for update, insert and delete queries. Since the query builder for these queries aren't exposed to the end user, this method opens up the API to build custom queries.

  Parameters

  • action: "insert"
  • client: QueryClientContract

  Returns InsertQueryBuilderContract<unknown[]>

• $getQueryFor(
      action: "delete" | "refresh" | "update",
      client: QueryClientContract,
  ): ModelQueryBuilderContract<LucidModel>

  Parameters

  • action: "delete" | "refresh" | "update"
  • client: QueryClientContract

  Returns ModelQueryBuilderContract<LucidModel>

$getRelated

• $getRelated(
      key: string,
      defaultValue?: any,
  ): OneOrMany<LucidRow> | null | undefined

  Parameters

  • key: string
  • OptionaldefaultValue: any

  Returns OneOrMany<LucidRow> | null | undefined

$hasRelated

• $hasRelated(key: string): boolean

  Read/write realtionships. Following methods are intentionally loosely typed, so that one can bypass the public facing API and type checking for advanced use cases

  Parameters

  • key: string

  Returns boolean

$hydrateOriginals

• $hydrateOriginals(): void

  Returns void

$pushRelated

• $pushRelated(key: string, result: OneOrMany<LucidRow> | null): void

  Parameters

  • key: string
  • result: OneOrMany<LucidRow> | null

  Returns void

$setAttribute

• $setAttribute(key: string, value: any): void

  Read/write attributes. Following methods are intentionally loosely typed, so that one can bypass the public facing API and type checking for advanced use cases

  Parameters

  • key: string
  • value: any

  Returns void

$setOptionsAndTrx

• $setOptionsAndTrx(options?: ModelAdapterOptions): void

  Parameters

  • Optionaloptions: ModelAdapterOptions

  Returns void

$setRelated

• $setRelated(key: string, result: OneOrMany<LucidRow> | null): void

  Parameters

  • key: string
  • result: OneOrMany<LucidRow> | null

  Returns void

delete

• delete(): Promise<void>

  Perform delete by issuing a delete request on the adapter

  Returns Promise<void>

deleteQuietly

• deleteQuietly(): Promise<void>

  Same as [[BaseModel.delete]] without invoking hooks

  Returns Promise<void>

enableForceUpdate

• enableForceUpdate(): this

  Enable force update even when no attributes are dirty

  Returns this

fill

• fill(
      value: Partial<ModelAttributes<this>>,
      allowExtraProperties?: boolean,
  ): this

  Parameters

  • value: Partial<ModelAttributes<this>>
  • OptionalallowExtraProperties: boolean

  Returns this

isDirty

• isDirty(fields?: "id" | "texto" | ("id" | "texto" | undefined)[]): boolean

  Parameters

  • Optionalfields: "id" | "texto" | ("id" | "texto" | undefined)[]

  Returns boolean

lockForUpdate

• lockForUpdate<T>(callback: (user: this) => T | Promise<T>): Promise<T>

  The lockForUpdate method re-fetches the model instance from the database and locks the row to perform an update. The provided callback receives a fresh user instance and should use that to perform an update.

  Type Parameters

  • T

  Parameters

  • callback: (user: this) => T | Promise<T>

  Returns Promise<T>

merge

• merge(
      value: Partial<ModelAttributes<this>>,
      allowExtraProperties?: boolean,
  ): this

  Parameters

  • value: Partial<ModelAttributes<this>>
  • OptionalallowExtraProperties: boolean

  Returns this

refresh

• refresh(): Promise<NominaTiposJornadas>

  Reload/Refresh the model instance

  Returns Promise<NominaTiposJornadas>

related

• related<Name extends undefined>(
      relation: Name,
  ): NonNullable<NominaTiposJornadas[Name]> extends ModelRelations<
      LucidModel,
      LucidModel,
  >
      ? (
          ModelRelations<LucidModel, LucidModel> & NominaTiposJornadas[Name] & {}
      )["client"]
      : never

  Returns related model for a given relationship

  Type Parameters

  • Name extends undefined

  Parameters

  • relation: Name

  Returns NonNullable<NominaTiposJornadas[Name]> extends ModelRelations<
      LucidModel,
      LucidModel,
  >
      ? (
          ModelRelations<LucidModel, LucidModel> & NominaTiposJornadas[Name] & {}
      )["client"]
      : never

save

• save(): Promise<NominaTiposJornadas>

  Actions to perform on the instance

  Returns Promise<NominaTiposJornadas>

saveQuietly

• saveQuietly(): Promise<NominaTiposJornadas>

  Perform save on the model without invoking hooks.

  Returns Promise<NominaTiposJornadas>

serialize

• serialize(cherryPick?: CherryPick): ModelObject

  Serialize model to a plain object

  Parameters

  • OptionalcherryPick: CherryPick

  Returns ModelObject

serializeAttributes

• serializeAttributes(fields?: CherryPickFields, raw?: boolean): ModelObject

  Serialize attributes to a plain object

  Parameters

  • Optionalfields: CherryPickFields
  • Optionalraw: boolean

  Returns ModelObject

serializeComputed

• serializeComputed(fields?: CherryPickFields): ModelObject

  Serialize computed properties to a plain object

  Parameters

  • Optionalfields: CherryPickFields

  Returns ModelObject

serializeRelations

• serializeRelations(
      fields: undefined,
      raw: true,
  ): { [key: string]: LucidRow | LucidRow[] }

  Serialize relationships to key-value pair of model instances and their serializeAs keys

  Parameters

  • fields: undefined
  • raw: true

  Returns { [key: string]: LucidRow | LucidRow[] }

• serializeRelations(
      cherryPick: { [relation: string]: CherryPick } | undefined,
      raw: false | undefined,
  ): ModelObject

  Serialize relationships to key-value pair of plain nested objects

  Parameters

  • cherryPick: { [relation: string]: CherryPick } | undefined
  • raw: false | undefined

  Returns ModelObject

• serializeRelations(
      cherryPick?: { [relation: string]: CherryPick },
      raw?: boolean,
  ): ModelObject

  Parameters

  • OptionalcherryPick: { [relation: string]: CherryPick }
  • Optionalraw: boolean

  Returns ModelObject

toJSON

• toJSON(): ModelObject

  Serialize everything

  Returns ModelObject

toObject

• toObject(): ModelObject

  Converts model to an object. It just returns the properties of the model, along with preloaded relationships

  Returns ModelObject

useConnection

• useConnection(connection: string): this

  Parameters

  • connection: string

  Returns this

useTransaction

• useTransaction(trx: TransactionClientContract): this

  Parameters

  • trx: TransactionClientContract

  Returns this

Static$addColumn

• $addColumn(name: string, options: Partial<ColumnOptions>): ColumnOptions

  Managing columns

  Parameters

  • name: string
  • options: Partial<ColumnOptions>

  Returns ColumnOptions

Static$addComputed

• $addComputed(name: string, options: Partial<ComputedOptions>): ComputedOptions

  Managing computed columns

  Parameters

  • name: string
  • options: Partial<ComputedOptions>

  Returns ComputedOptions

Static$addRelation

• $addRelation(
      name: string,
      type: "hasOne" | "hasMany" | "belongsTo" | "manyToMany" | "hasManyThrough",
      relatedModel: () => LucidModel,
      options: ModelRelationOptions,
  ): void

  Managing relationships

  Parameters

  • name: string
  • type: "hasOne" | "hasMany" | "belongsTo" | "manyToMany" | "hasManyThrough"
  • relatedModel: () => LucidModel
  • options: ModelRelationOptions

  Returns void

Static$createFromAdapterResult

• $createFromAdapterResult<T extends LucidModel>(
      this: T,
      result?: ModelObject,
      sideloadAttributes?: ModelObject,
      options?: ModelAdapterOptions,
  ): InstanceType<T> | null

  Creating model from adapter results

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • Optionalresult: ModelObject
  • OptionalsideloadAttributes: ModelObject
  • Optionaloptions: ModelAdapterOptions

  Returns InstanceType<T> | null

Static$createMultipleFromAdapterResult

• $createMultipleFromAdapterResult<T extends LucidModel>(
      this: T,
      results: ModelObject[],
      sideloadAttributes?: ModelObject,
      options?: ModelAdapterOptions,
  ): InstanceType<T>[]

  Creating multiple model instances from an array of adapter result

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • results: ModelObject[]
  • OptionalsideloadAttributes: ModelObject
  • Optionaloptions: ModelAdapterOptions

  Returns InstanceType<T>[]

Static$defineProperty

• $defineProperty<Model extends LucidModel, Prop extends string | number | symbol>(
      this: Model,
      propertyName: Prop,
      defaultValue: Model[Prop],
      strategy: "define" | "inherit" | ((value: Model[Prop]) => Model[Prop]),
  ): void

  Define a static property on the model using the inherit or define strategy.

  Inherit strategy will clone the property from the parent model and will set it on the current model

  Type Parameters

  • Model extends LucidModel
  • Prop extends string | number | symbol

  Parameters

  • this: Model
  • propertyName: Prop
  • defaultValue: Model[Prop]
  • strategy: "define" | "inherit" | ((value: Model[Prop]) => Model[Prop])

  Returns void

Static$getColumn

• $getColumn(name: string): ModelColumnOptions | undefined

  Parameters

  • name: string

  Returns ModelColumnOptions | undefined

Static$getComputed

• $getComputed(name: string): ComputedOptions | undefined

  Parameters

  • name: string

  Returns ComputedOptions | undefined

Static$getRelation

• $getRelation<Model extends LucidModel, Name extends string | number | symbol>(
      this: Model,
      name: Name,
  ): NonNullable<InstanceType<Model>[Name]> extends ModelRelations<
      LucidModel,
      LucidModel,
  >
      ? NonNullable<NonNullable<InstanceType<Model>[Name]>>["client"]["relation"]
      : RelationshipsContract

  Get relationship declaration

  Type Parameters

  • Model extends LucidModel
  • Name extends string | number | symbol

  Parameters

  • this: Model
  • name: Name

  Returns NonNullable<InstanceType<Model>[Name]> extends ModelRelations<
      LucidModel,
      LucidModel,
  >
      ? NonNullable<NonNullable<InstanceType<Model>[Name]>>["client"]["relation"]
      : RelationshipsContract

• $getRelation<Model extends LucidModel>(
      this: Model,
      name: string,
  ): RelationshipsContract

  Type Parameters

  • Model extends LucidModel

  Parameters

  • this: Model
  • name: string

  Returns RelationshipsContract

Static$hasColumn

• $hasColumn(name: string): boolean

  Parameters

  • name: string

  Returns boolean

Static$hasComputed

• $hasComputed(name: string): boolean

  Parameters

  • name: string

  Returns boolean

Static$hasRelation

• $hasRelation(name: string): boolean

  Find if a relationship exists

  Parameters

  • name: string

  Returns boolean

Staticafter

• after<Model extends LucidModel>(
      this: Model,
      event: "fetch",
      handler: HooksHandler<InstanceType<Model>[], "fetch">,
  ): void

  Register an after hook

  Type Parameters

  • Model extends LucidModel

  Parameters

  • this: Model
  • event: "fetch"
  • handler: HooksHandler<InstanceType<Model>[], "fetch">

  Returns void

• after<Model extends LucidModel>(
      this: Model,
      event: "paginate",
      handler: HooksHandler<
          ModelPaginatorContract<InstanceType<Model>>,
          "paginate",
      >,
  ): void

  Type Parameters

  • Model extends LucidModel

  Parameters

  • this: Model
  • event: "paginate"
  • handler: HooksHandler<ModelPaginatorContract<InstanceType<Model>>, "paginate">

  Returns void

• after<Model extends LucidModel, Event extends EventsList>(
      this: Model,
      event: Event,
      handler: HooksHandler<InstanceType<Model>, Event>,
  ): void

  Type Parameters

  • Model extends LucidModel
  • Event extends EventsList

  Parameters

  • this: Model
  • event: Event
  • handler: HooksHandler<InstanceType<Model>, Event>

  Returns void

Staticall

• all<T extends LucidModel>(
      this: T,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>[]>

  Fetch all rows

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>[]>

Staticbefore

• before<Model extends LucidModel, Event extends "find" | "fetch">(
      this: Model,
      event: Event,
      handler: HooksHandler<
          ModelQueryBuilderContract<Model, InstanceType<Model>>,
          Event,
      >,
  ): void

  Register a before hook

  Type Parameters

  • Model extends LucidModel
  • Event extends "find" | "fetch"

  Parameters

  • this: Model
  • event: Event
  • handler: HooksHandler<ModelQueryBuilderContract<Model, InstanceType<Model>>, Event>

  Returns void

• before<Model extends LucidModel>(
      this: Model,
      event: "paginate",
      handler: HooksHandler<
          [
              ModelQueryBuilderContract<Model, InstanceType<Model>>,
              ModelQueryBuilderContract<Model, InstanceType<Model>>,
          ],
          "paginate",
      >,
  ): void

  Type Parameters

  • Model extends LucidModel

  Parameters

  • this: Model
  • event: "paginate"
  • handler: HooksHandler<
        [
            ModelQueryBuilderContract<Model, InstanceType<Model>>,
            ModelQueryBuilderContract<Model, InstanceType<Model>>,
        ],
        "paginate",
    >

  Returns void

• before<Model extends LucidModel, Event extends EventsList>(
      this: Model,
      event: Event,
      handler: HooksHandler<InstanceType<Model>, Event>,
  ): void

  Type Parameters

  • Model extends LucidModel
  • Event extends EventsList

  Parameters

  • this: Model
  • event: Event
  • handler: HooksHandler<InstanceType<Model>, Event>

  Returns void

Staticboot

• boot(): void

  Boot model

  Returns void

Staticcreate

• create<T extends LucidModel>(
      this: T,
      values: Partial<ModelAttributes<InstanceType<T>>>,
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>>

  Create model and return its instance back

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • values: Partial<ModelAttributes<InstanceType<T>>>
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>>

StaticcreateMany

• createMany<T extends LucidModel>(
      this: T,
      values: Partial<ModelAttributes<InstanceType<T>>>[],
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>[]>

  Create many of model instances

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • values: Partial<ModelAttributes<InstanceType<T>>>[]
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>[]>

StaticcreateManyQuietly

• createManyQuietly<T extends LucidModel>(
      this: T,
      values: Partial<ModelAttributes<InstanceType<T>>>[],
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>[]>

  Same as [[BaseModel.createMany]] but without invoking hooks

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • values: Partial<ModelAttributes<InstanceType<T>>>[]
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>[]>

StaticcreateQuietly

• createQuietly<T extends LucidModel>(
      this: T,
      values: Partial<ModelAttributes<InstanceType<T>>>,
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>>

  Same as [[BaseModel.create]] but without invoking hooks

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • values: Partial<ModelAttributes<InstanceType<T>>>
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>>

StaticfetchOrCreateMany

• fetchOrCreateMany<T extends LucidModel>(
      this: T,
      predicate:
          | keyof ModelAttributes<InstanceType<T>>
          | (keyof ModelAttributes<InstanceType<T>>)[],
      payload: Partial<ModelAttributes<InstanceType<T>>>[],
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>[]>

  Find rows or create many when missing. One db call is invoked for each create

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • predicate:
        | keyof ModelAttributes<InstanceType<T>>
        | (keyof ModelAttributes<InstanceType<T>>)[]
  • payload: Partial<ModelAttributes<InstanceType<T>>>[]
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>[]>

StaticfetchOrNewUpMany

• fetchOrNewUpMany<T extends LucidModel>(
      this: T,
      predicate:
          | keyof ModelAttributes<InstanceType<T>>
          | (keyof ModelAttributes<InstanceType<T>>)[],
      payload: Partial<ModelAttributes<InstanceType<T>>>[],
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>[]>

  Find rows or create in-memory instances of the missing one's.

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • predicate:
        | keyof ModelAttributes<InstanceType<T>>
        | (keyof ModelAttributes<InstanceType<T>>)[]
  • payload: Partial<ModelAttributes<InstanceType<T>>>[]
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>[]>

Staticfind

• find<T extends LucidModel>(
      this: T,
      value: any,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T> | null>

  Find one using the primary key

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • value: any
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T> | null>

StaticfindBy

• findBy<T extends LucidModel>(
      this: T,
      clause: Record<string, unknown>,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T> | null>

  Find one using a clause

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • clause: Record<string, unknown>
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T> | null>

• findBy<T extends LucidModel>(
      this: T,
      key: string,
      value: any,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T> | null>

  Find one using a key-value pair

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • key: string
  • value: any
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T> | null>

StaticfindByOrFail

• findByOrFail<T extends LucidModel>(
      this: T,
      clause: Record<string, unknown>,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>>

  Find one using a clause or fail

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • clause: Record<string, unknown>
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>>

• findByOrFail<T extends LucidModel>(
      this: T,
      key: string,
      value: any,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>>

  Find one using a key-value pair or fail

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • key: string
  • value: any
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>>

StaticfindMany

• findMany<T extends LucidModel>(
      this: T,
      value: any[],
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>[]>

  Find many using an array of primary keys

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • value: any[]
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>[]>

StaticfindManyBy

• findManyBy<T extends LucidModel>(
      this: T,
      clause: Record<string, unknown>,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>[]>

  Find multiple models instance using a clause

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • clause: Record<string, unknown>
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>[]>

• findManyBy<T extends LucidModel>(
      this: T,
      key: string,
      value: any,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>[]>

  Find multiple models instance using a key/value pair

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • key: string
  • value: any
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>[]>

StaticfindOrFail

• findOrFail<T extends LucidModel>(
      this: T,
      value: any,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>>

  Find one using the primary key or fail

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • value: any
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>>

Staticfirst

• first<T extends LucidModel>(
      this: T,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T> | null>

  Same as query().first()

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T> | null>

StaticfirstOrCreate

• firstOrCreate<T extends LucidModel>(
      this: T,
      searchPayload: Partial<ModelAttributes<InstanceType<T>>>,
      savePayload?: Partial<ModelAttributes<InstanceType<T>>>,
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>>

  Returns the first row or save it to the database

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • searchPayload: Partial<ModelAttributes<InstanceType<T>>>
  • OptionalsavePayload: Partial<ModelAttributes<InstanceType<T>>>
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>>

StaticfirstOrFail

• firstOrFail<T extends LucidModel>(
      this: T,
      options?: ModelAdapterOptions,
  ): Promise<InstanceType<T>>

  Same as query().firstOrFail()

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • Optionaloptions: ModelAdapterOptions

  Returns Promise<InstanceType<T>>

StaticfirstOrNew

• firstOrNew<T extends LucidModel>(
      this: T,
      searchPayload: Partial<ModelAttributes<InstanceType<T>>>,
      savePayload?: Partial<ModelAttributes<InstanceType<T>>>,
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>>

  Returns the first row or create a new instance of model without persisting it

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • searchPayload: Partial<ModelAttributes<InstanceType<T>>>
  • OptionalsavePayload: Partial<ModelAttributes<InstanceType<T>>>
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>>

Staticquery

• query<Model extends LucidModel, Result = InstanceType<Model>>(
      this: Model,
      options?: ModelAdapterOptions,
  ): ModelQueryBuilderContract<Model, Result>

  Returns the query for fetching a model instance

  Type Parameters

  • Model extends LucidModel
  • Result = InstanceType<Model>

  Parameters

  • this: Model
  • Optionaloptions: ModelAdapterOptions

  Returns ModelQueryBuilderContract<Model, Result>

Statictruncate

• truncate(cascade?: boolean): Promise<void>

  Truncate model table

  Parameters

  • Optionalcascade: boolean

  Returns Promise<void>

StaticupdateOrCreate

• updateOrCreate<T extends LucidModel>(
      this: T,
      searchPayload: Partial<ModelAttributes<InstanceType<T>>>,
      updatePayload: Partial<ModelAttributes<InstanceType<T>>>,
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>>

  Returns the first row or save it to the database

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • searchPayload: Partial<ModelAttributes<InstanceType<T>>>
  • updatePayload: Partial<ModelAttributes<InstanceType<T>>>
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>>

StaticupdateOrCreateMany

• updateOrCreateMany<T extends LucidModel>(
      this: T,
      predicate:
          | keyof ModelAttributes<InstanceType<T>>
          | (keyof ModelAttributes<InstanceType<T>>)[],
      payload: Partial<ModelAttributes<InstanceType<T>>>[],
      options?: ModelAssignOptions,
  ): Promise<InstanceType<T>[]>

  Update existing rows or create new one's.

  Type Parameters

  • T extends LucidModel

  Parameters

  • this: T
  • predicate:
        | keyof ModelAttributes<InstanceType<T>>
        | (keyof ModelAttributes<InstanceType<T>>)[]
  • payload: Partial<ModelAttributes<InstanceType<T>>>[]
  • Optionaloptions: ModelAssignOptions

  Returns Promise<InstanceType<T>[]>

StaticuseAdapter

• useAdapter(adapter: AdapterContract): void

  Define an adapter to use for interacting with the database

  Parameters

  • adapter: AdapterContract

  Returns void