Options
All
  • Public
  • Public/Protected
  • All
Menu

Soukai API

Index

Classes

Interfaces

Type Aliases

Variables

Functions

Type Aliases

ArrayFieldDefinition

ArrayFieldDefinition<T>: FieldDefinitionBase<T> & { items: Omit<FieldDefinition<T>, "required">; type: typeof Array }

Type Parameters

  • T = unknown

AttributeValue

AttributeValue: any

Attributes

Attributes: Record<string, AttributeValue>

BasicFieldDefinition

BasicFieldDefinition<T>: FieldDefinitionBase<T> & { type: Exclude<FieldTypeValue, typeof Array | typeof Object> }

Type Parameters

  • T = unknown

BootedArrayFieldDefinition

BootedArrayFieldDefinition<T>: BootedFieldDefinitionBase<T> & { items: Omit<BootedFieldDefinition<T>, "required">; type: typeof Array }

Type Parameters

  • T = unknown

BootedBasicFieldDefinition

BootedBasicFieldDefinition<T>: BootedFieldDefinitionBase<T> & { type: Exclude<FieldTypeValue, typeof Array | typeof Object> }

Type Parameters

  • T = unknown

BootedFieldDefinition

BootedFieldDefinition<T>: BootedBasicFieldDefinition<T> | BootedArrayFieldDefinition<T> | BootedObjectFieldDefinition<T>

Type Parameters

  • T = unknown

BootedFieldDefinitionBase

BootedFieldDefinitionBase<T>: T & { required: boolean }

Type Parameters

  • T = unknown

BootedFieldsDefinition

BootedFieldsDefinition<T>: Record<string, BootedFieldDefinition<T>>

Type Parameters

  • T = unknown

BootedObjectFieldDefinition

BootedObjectFieldDefinition<T>: BootedFieldDefinitionBase<T> & { fields: BootedFieldsDefinition<T>; type: typeof Object }

Type Parameters

  • T = unknown

EngineAttributeFilter

EngineAttributeFilter: EngineAttributeValue | { $eq: EngineAttributeValue } | { $or: EngineAttributeFilter[] } | { $in: EngineAttributeLeafValue[] } | { $contains: EngineAttributeFilter | EngineAttributeFilter[] }

EngineAttributeLeafValue

EngineAttributeLeafValue: string | number | boolean | null | Date

EngineAttributeUpdate

EngineAttributeUpdate: EngineAttributeValue | EngineAttributeUpdateMap | EngineAttributeUpdateOperation | { $apply: EngineAttributeUpdateOperation[] }

EngineAttributeUpdateOperation

EngineAttributeUpdateOperation: { $update: EngineAttributeUpdate } | { $updateItems: EngineUpdateItemsOperatorData | EngineUpdateItemsOperatorData[] } | { $unset: string | string[] | true } | { $push: EngineAttributeValue }

EngineAttributeValue

EngineAttributeValue: EngineAttributeLeafValue | EngineAttributeValueMap | EngineAttributeValueArray | EngineAttributeValueArrayMap

EngineDocument

EngineDocument: Record<string, EngineAttributeValue>

EngineDocumentsCollection

EngineDocumentsCollection: Record<string, EngineDocument>

EngineFilters

EngineFilters: EngineRootFilter & Record<string, EngineAttributeFilter>

EngineUpdates

EngineUpdates: Record<string, EngineAttributeUpdate> | { $unset: string | string[] } | { $overwrite: EngineAttributeValue }

FieldDefinition

FieldDefinition<T>: BasicFieldDefinition<T> | ArrayFieldDefinition<T> | ObjectFieldDefinition<T> | FieldTypeValue | Record<string, FieldTypeValue>

Type Parameters

  • T = unknown

FieldDefinitionBase

FieldDefinitionBase<T>: T & { required?: boolean }

Type Parameters

  • T = unknown

FieldTypeValue

FieldTypeValue: typeof FieldType[keyof typeof FieldType]

FieldsDefinition

FieldsDefinition<T>: Record<string, FieldDefinition<T>>

Type Parameters

  • T = unknown

GetArrayFields

GetArrayFields<F>: { [ K in keyof F]: F[K] extends { type: typeof Array } ? K : never }[keyof F]

Type Parameters

GetDefinedFields

GetDefinedFields<F>: { [ K in keyof F]: F[K] extends string | { type: string } ? K : F[K] extends Record<string, string> ? K : never }[keyof F]

Type Parameters

GetFieldType

GetFieldType<T>: T extends FieldTypeValue ? T : T extends BasicFieldDefinition ? T["type"] : T extends ArrayFieldDefinition ? T["items"][] : T extends ObjectFieldDefinition ? T["fields"] : T

Type Parameters

GetFieldsDefinition

GetFieldsDefinition<D>: D extends { fields: infer F } ? F : {}

Type Parameters

GetRequiredFields

GetRequiredFields<F>: { [ K in keyof F]: F[K] extends { required: true } ? K : never }[keyof F]

Type Parameters

GetTimestampsDefinition

GetTimestampsDefinition<D>: D extends { timestamps: infer T } ? T : true

Type Parameters

Key

Key: any

MagicAttributeProperties

MagicAttributeProperties<T>: { -readonly [ K in keyof T]: MagicAttributeValue<GetFieldType<T[K]>> }

Type Parameters

MagicAttributeValue

MagicAttributeValue<T>: T extends FieldsDefinition ? NestedMagicAttributes<T> : T extends FieldTypeValue ? ResolveFieldType<T> : T extends (infer R)[] ? R extends FieldTypeValue ? ResolveFieldType<R>[] : never : never

Type Parameters

  • T

MagicAttributes

MagicAttributes<S>: Pretty<MagicAttributeProperties<{ id: typeof String }> & NestedMagicAttributes<GetFieldsDefinition<S>> & MagicTimestampAttributes<GetTimestampsDefinition<S>>>

Type Parameters

MagicTimestampAttributes

MagicTimestampAttributes<T>: T extends false ? {} : T extends typeof CreatedAt[] ? { createdAt: Date } : T extends typeof UpdatedAt[] ? { updatedAt: Date } : { createdAt: Date; updatedAt: Date }

Type Parameters

ModelCastAttributeOptions

ModelCastAttributeOptions: { definition?: BootedFieldDefinition; field?: string; malformedAttributes?: Record<string, string[]> }

Type declaration

  • Optional definition?: BootedFieldDefinition
  • Optional field?: string
  • Optional malformedAttributes?: Record<string, string[]>

ModelCloneOptions

ModelCloneOptions: Partial<{ clean: boolean; clones: WeakMap<Model, Model>; constructors: WeakMap<typeof Model, typeof Model> | [typeof Model, typeof Model][] }>

ModelConstructor

ModelConstructor<T>: Constructor<T> & typeof Model

Type Parameters

ModelEventValue

ModelEventValue: typeof ModelEvent[keyof typeof ModelEvent]

ModelListener

ModelListener<T>: ((model: T) => unknown)

Type Parameters

Type declaration

    • (model: T): unknown

    • Parameters

      • model: T

      Returns unknown

NestedMagicAttributes

NestedMagicAttributes<T>: MagicAttributeProperties<Pick<T, GetRequiredFields<T>>> & Partial<MagicAttributeProperties<Pick<T, GetDefinedFields<T>>>>

Type Parameters

ObjectFieldDefinition

ObjectFieldDefinition<T>: FieldDefinitionBase<T> & { fields: FieldsDefinition<T>; type: typeof Object }

Type Parameters

  • T = unknown

RelationCloneOptions

RelationCloneOptions: Partial<{ clones: WeakMap<Model, Model>; constructors: WeakMap<typeof Model, typeof Model> }>

RelationConstructor

RelationConstructor<T>: Constructor<T> & typeof Relation

Type Parameters

RelationDeleteStrategy

RelationDeleteStrategy: null | "cascade"

ResolveFieldType

ResolveFieldType<T>: T extends typeof Number ? number : T extends typeof String ? string : T extends typeof Boolean ? boolean : T extends typeof Date ? Date : T extends typeof Key ? Key : T extends typeof Any ? any : never

Type Parameters

SchemaDefinition

SchemaDefinition<T>: Partial<{ fields: FieldsDefinition<T>; primaryKey: string; timestamps: TimestampsDefinition }>

Type Parameters

  • T = unknown

TimestampFieldValue

TimestampFieldValue: typeof TimestampField[keyof typeof TimestampField]

TimestampsDefinition

TimestampsDefinition: TimestampFieldValue[] | boolean

Variables

Const FieldRequired

FieldRequired: { Optional: false; Required: true } = ...

Type declaration

  • Optional: false
  • Required: true

Const FieldType

FieldType: { Any: "any"; Array: "array"; Boolean: "boolean"; Date: "date"; Key: "key"; Number: "number"; Object: "object"; String: "string" } = ...

Type declaration

  • Any: "any"
  • Array: "array"
  • Boolean: "boolean"
  • Date: "date"
  • Key: "key"
  • Number: "number"
  • Object: "object"
  • String: "string"

Const ModelEvent

ModelEvent: { Created: "created"; Deleted: "deleted"; Updated: "updated" } = ...

Type declaration

  • Created: "created"
  • Deleted: "deleted"
  • Updated: "updated"

Const TimestampField

TimestampField: { CreatedAt: "createdAt"; UpdatedAt: "updatedAt" } = ...

Type declaration

  • CreatedAt: "createdAt"
  • UpdatedAt: "updatedAt"

default

default: Soukai
deprecated

import global methods instead.

Functions

bootModels

  • bootModels(models: Record<string, typeof Model>): void

bootModelsFromViteGlob

  • bootModelsFromViteGlob(glob: Record<string, Record<string, unknown>>, ignoreSuffixes?: string[]): void

bootModelsFromWebpackContext

  • bootModelsFromWebpackContext(context: RequireContext, ignoreSuffixes?: string[]): void

closeEngineConnections

  • closeEngineConnections(): Promise<void>

defineModelSchema

definitionsFromContexts

  • definitionsFromContexts(context: RequireContext): Record<string, typeof Model>
  • deprecated

    This was intended for loading models, but that isn't necessary anymore. Maybe you want to use bootModelsFromWebpackContext instead.

    Parameters

    • context: RequireContext

    Returns Record<string, typeof Model>

engineClosesConnections

extractFinalEngine

getEngine

  • getEngine(): Engine | undefined

getFinalEngine

  • getFinalEngine(): Engine | undefined

getModelsFromViteGlob

  • getModelsFromViteGlob(glob: Record<string, Record<string, unknown>>, ignoreSuffixes?: string[]): Record<string, typeof Model>

getModelsFromWebpackContext

  • getModelsFromWebpackContext(context: RequireContext, ignoreSuffixes?: string[]): Record<string, typeof Model>

isArrayFieldDefinition

isObjectFieldDefinition

isProxyEngine

requireBootedModel

  • requireBootedModel<T>(name: string): T

requireEngine

  • requireEngine<T>(): T

requireFinalEngine

  • requireFinalEngine<T>(): T

setEngine

  • setEngine(engine: null | Engine): void

withEngine

  • withEngine<T>(engine: Engine, operation: (() => T)): T
  • withEngine<T>(engine: Engine, operation: (() => Promise<T>)): Promise<T>

Generated using TypeDoc