bun-query-builder 0.1.12 → 0.1.15

package/dist/orm.d.ts

@@ -1,4 +1,4 @@
-import { Database } from 'bun:sqlite';
+import { Database, type SQLQueryBindings } from 'bun:sqlite';
 import type { Faker } from 'ts-mocker';
 export type {
   ModelInstance,
@@ -19,7 +19,7 @@ export declare function getDatabase(): Database;
  */
 export declare function createModel<const TDef extends ModelDefinition>(definition: TDef): void;
 export declare function createTableFromModel(definition: ModelDefinition): void;
-export declare function seedModel(definition: ModelDefinition, count?: number, faker?: any): Promise<void>;
+export declare function seedModel(definition: ModelDefinition, count?: number, faker?: Record<string, unknown>): Promise<void>;
 // Attribute definition with explicit type
 export declare interface TypedAttribute<T = unknown> {
   type?: T
@@ -30,20 +30,26 @@ export declare interface TypedAttribute<T = unknown> {
   guarded?: boolean
   nullable?: boolean
   default?: InferType<T>
+  foreignKey?: boolean | import('./schema').ForeignKeyConfig
   validation?: {
     rule: unknown
     message?: Record<string, string>
   }
   factory?: (faker: Faker) => InferType<T>
 }
+/** Structural type for model instances passed to lifecycle hooks. */
+// eslint-disable-next-line ts/no-empty-object-type
+export declare interface ModelHookInstance extends Record<string, unknown> {
+  get(key: string): unknown
+}
 // Base model definition
 export declare interface ModelDefinition {
-  name: string
-  table: string
-  primaryKey?: string
-  autoIncrement?: boolean
-  connection?: string
-  traits?: {
+  readonly name: string
+  readonly table: string
+  readonly primaryKey?: string
+  readonly autoIncrement?: boolean
+  readonly connection?: string
+  readonly traits?: {
     readonly useUuid?: boolean
     readonly useTimestamps?: boolean | object
     readonly timestampable?: boolean | object
@@ -80,36 +86,36 @@ export declare interface ModelDefinition {
     readonly useActivityLog?: boolean | object
     readonly useSocials?: readonly string[]
   }
-  belongsTo?: readonly string[]
-  hasMany?: readonly string[]
-  hasOne?: readonly string[]
-  belongsToMany?: readonly (string | object)[]
-  hasOneThrough?: readonly (string | object)[]
-  hasManyThrough?: readonly (string | object)[]
-  morphOne?: string | object
-  morphMany?: readonly (string | object)[]
-  morphTo?: object
-  morphToMany?: readonly string[]
-  morphedByMany?: readonly string[]
-  attributes: {
+  readonly belongsTo?: readonly string[] | Readonly<Record<string, string>>
+  readonly hasMany?: readonly string[] | Readonly<Record<string, string>>
+  readonly hasOne?: readonly string[] | Readonly<Record<string, string>>
+  readonly belongsToMany?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly hasOneThrough?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly hasManyThrough?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly morphOne?: string | object | Readonly<Record<string, string>>
+  readonly morphMany?: readonly (string | object)[] | Readonly<Record<string, string | object>>
+  readonly morphTo?: object
+  readonly morphToMany?: readonly string[]
+  readonly morphedByMany?: readonly string[]
+  readonly attributes: {
     readonly [key: string]: TypedAttribute<unknown>
   }
-  get?: Record<string, (attributes: Record<string, unknown>) => unknown>
-  set?: Record<string, (attributes: Record<string, unknown>) => unknown>
-  scopes?: Record<string, (value: unknown) => unknown>
-  indexes?: readonly object[]
-  dashboard?: { readonly highlight?: boolean | number }
-  hooks?: {
-    readonly beforeCreate?: (data: any) => void | Promise<void>
-    readonly afterCreate?: (model: any) => void | Promise<void>
-    readonly beforeUpdate?: (model: any, data: any) => void | Promise<void>
-    readonly afterUpdate?: (model: any) => void | Promise<void>
-    readonly beforeDelete?: (model: any) => void | Promise<void>
-    readonly afterDelete?: (model: any) => void | Promise<void>
+  readonly get?: Record<string, (attributes: Record<string, unknown>) => unknown>
+  readonly set?: Record<string, (attributes: Record<string, unknown>) => unknown>
+  readonly scopes?: Record<string, (value: unknown) => unknown>
+  readonly indexes?: readonly object[]
+  readonly dashboard?: { readonly highlight?: boolean | number }
+  readonly hooks?: {
+    readonly beforeCreate?: (data: Record<string, unknown>) => void | Promise<void>
+    readonly afterCreate?: (model: ModelHookInstance) => void | Promise<void>
+    readonly beforeUpdate?: (model: ModelHookInstance, data: Record<string, unknown>) => void | Promise<void>
+    readonly afterUpdate?: (model: ModelHookInstance) => void | Promise<void>
+    readonly beforeDelete?: (model: ModelHookInstance) => void | Promise<void>
+    readonly afterDelete?: (model: ModelHookInstance) => void | Promise<void>
   }
 }
 // Binding helper type for SQL queries
-declare type Bindings = SQLQueryBindings[]
+declare type Bindings = SQLQueryBindings[];
 // Primitive type mappings
 declare type PrimitiveTypeMap = {
   string: string
@@ -122,13 +128,13 @@ declare type PrimitiveTypeMap = {
 declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
   T extends readonly (infer U)[] ? U :
   T extends (infer U)[] ? U :
-  unknown
+  unknown;
 // Extract attribute keys from definition
-declare type AttributeKeys<TDef extends ModelDefinition> = keyof TDef['attributes'] & string
+declare type AttributeKeys<TDef extends ModelDefinition> = keyof TDef['attributes'] & string;
 // Infer single attribute type
 declare type InferAttributeType<TAttr> = TAttr extends { type: infer T } ? InferType<T> :
   TAttr extends { factory: (faker: Faker) => infer R } ? R :
-  unknown
+  unknown;
 // Build the full attributes type from definition
 declare type InferModelAttributes<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: InferAttributeType<TDef['attributes'][K]>
@@ -136,58 +142,83 @@ declare type InferModelAttributes<TDef extends ModelDefinition> = {
 // System fields added by traits
 declare type SystemFields<TDef extends ModelDefinition> = { id: number } &
   (TDef['traits'] extends { useUuid: true } ? { uuid: string } : {}) &
-  (TDef['traits'] extends { useTimestamps: true } ? { created_at: string; updated_at: string } : {}) &
-  (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {})
+  (TDef['traits'] extends { useTimestamps: true } ? { created_at: string; updated_at: string | null } : {}) &
+  (TDef['traits'] extends { timestampable: true | object } ? { created_at: string; updated_at: string | null } : {}) &
+  (TDef['traits'] extends { useSoftDeletes: true } ? { deleted_at: string | null } : {}) &
+  (TDef['traits'] extends { softDeletable: true | object } ? { deleted_at: string | null } : {}) &
+  (TDef['traits'] extends { useAuth: true | object } ? { two_factor_secret: string | null; public_key: string | null } : {}) &
+  (TDef['traits'] extends { billable: true | object } ? { stripe_id: string | null } : {});
 // Complete model type
-declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SystemFields<TDef>
+declare type ModelAttributes<TDef extends ModelDefinition> = InferModelAttributes<TDef> & SystemFields<TDef>;
 // All valid column names
 declare type ColumnName<TDef extends ModelDefinition> = | AttributeKeys<TDef>
   | 'id'
   | (TDef['traits'] extends { useUuid: true } ? 'uuid' : never)
   | (TDef['traits'] extends { useTimestamps: true } ? 'created_at' | 'updated_at' : never)
+  | (TDef['traits'] extends { timestampable: true | object } ? 'created_at' | 'updated_at' : never)
   | (TDef['traits'] extends { useSoftDeletes: true } ? 'deleted_at' : never)
+  | (TDef['traits'] extends { softDeletable: true | object } ? 'deleted_at' : never)
+  | (TDef['traits'] extends { useAuth: true | object } ? 'two_factor_secret' | 'public_key' : never)
+  | (TDef['traits'] extends { billable: true | object } ? 'stripe_id' : never);
 // Hidden fields
 declare type HiddenKeys<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { hidden: true } ? K : never
-}[AttributeKeys<TDef>]
+}[AttributeKeys<TDef>];
 // Fillable fields
 declare type FillableKeys<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { fillable: true } ? K : never
-}[AttributeKeys<TDef>]
-// Infer relation names from model definition
-declare type InferBelongsToNames<TDef> = TDef extends { belongsTo: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never
-declare type InferHasManyNames<TDef> = TDef extends { hasMany: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never
-declare type InferHasOneNames<TDef> = TDef extends { hasOne: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : never : never
-declare type InferBelongsToManyNames<TDef> = TDef extends { belongsToMany: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never
-declare type InferHasOneThroughNames<TDef> = TDef extends { hasOneThrough: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never
-declare type InferHasManyThroughNames<TDef> = TDef extends { hasManyThrough: readonly (infer R)[] }
-    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never
+}[AttributeKeys<TDef>];
+// Numeric attribute columns — constrains aggregate methods (sum, avg, etc.)
+declare type NumericColumns<TDef extends ModelDefinition> = {
+  [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { type: 'number' } ? K : never
+}[AttributeKeys<TDef>];
+// Infer relation names from model definition (supports both array and object syntax)
+declare type InferBelongsToNames<TDef> = (TDef extends { belongsTo: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : never : never)
+  | (TDef extends { belongsTo: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type InferHasManyNames<TDef> = (TDef extends { hasMany: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : never : never)
+  | (TDef extends { hasMany: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type InferHasOneNames<TDef> = (TDef extends { hasOne: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : never : never)
+  | (TDef extends { hasOne: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type InferBelongsToManyNames<TDef> = (TDef extends { belongsToMany: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
+  | (TDef extends { belongsToMany: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type InferHasOneThroughNames<TDef> = (TDef extends { hasOneThrough: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
+  | (TDef extends { hasOneThrough: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
+declare type InferHasManyThroughNames<TDef> = (TDef extends { hasManyThrough: readonly (infer R)[] }
+    ? R extends string ? Lowercase<R> : R extends { model: infer M extends string } ? Lowercase<M> : never : never)
+  | (TDef extends { hasManyThrough: Readonly<Record<infer K, unknown>> }
+    ? K extends string ? K : never : never);
 export type InferRelationNames<TDef> = | InferBelongsToNames<TDef>
   | InferHasManyNames<TDef>
   | InferHasOneNames<TDef>
   | InferBelongsToManyNames<TDef>
   | InferHasOneThroughNames<TDef>
-  | InferHasManyThroughNames<TDef>
-declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in'
+  | InferHasManyThroughNames<TDef>;
+declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'in' | 'not in';
 /**
  * Model instance - represents a single database record
  */
 declare class ModelInstance<TDef extends ModelDefinition, TSelected extends ColumnName<TDef> = ColumnName<TDef>> {
-  private _attributes: Record<string, unknown>;
-  private _original: Record<string, unknown>;
-  private _definition: TDef;
-  private _hasSaved: any;
   constructor(definition: TDef, attributes?: Partial<ModelAttributes<TDef>>);
   get<K extends TSelected>(key: K): K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : never;
-  set<K extends AttributeKeys<TDef>>(key: K, value: ModelAttributes<TDef>[K]): void;
-  isDirty<K extends AttributeKeys<TDef>>(column?: K): boolean;
-  isClean<K extends AttributeKeys<TDef>>(column?: K): boolean;
-  getOriginal<K extends AttributeKeys<TDef>>(column: K): ModelAttributes<TDef>[K];
+  set<K extends ColumnName<TDef>>(key: K, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): void;
+  getRelation(name: string): ModelInstance<any, any>[] | ModelInstance<any, any> | null | undefined;
+  setRelation(name: string, data: ModelInstance<any, any>[] | ModelInstance<any, any> | null): void;
+  getLoadedRelations(): Record<string, ModelInstance<any, any>[] | ModelInstance<any, any> | null>;
+  get attributes(): Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>;
+  get id(): number;
+  isDirty(column?: ColumnName<TDef>): boolean;
+  isClean(column?: ColumnName<TDef>): boolean;
+  getOriginal<K extends ColumnName<TDef>>(column: K): K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown;
   getChanges(): Partial<InferModelAttributes<TDef>>;
   fill(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
   forceFill(data: Partial<InferModelAttributes<TDef>>): this;
@@ -195,27 +226,29 @@ declare class ModelInstance<TDef extends ModelDefinition, TSelected extends Colu
   update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
   delete(): boolean;
   refresh(): this;
+  replicate(): ModelInstance<TDef, TSelected>;
   toJSON(): Omit<Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>, HiddenKeys<TDef>>;
+  toArray(): Omit<Pick<ModelAttributes<TDef>, TSelected & keyof ModelAttributes<TDef>>, HiddenKeys<TDef>>;
 }
 /**
  * Query builder with precise type narrowing
  */
 declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends ColumnName<TDef> = ColumnName<TDef>> {
-  private _definition: TDef;
-  private _wheres: { column: string; operator: WhereOperator; value: unknown; boolean: 'and' | 'or' }[];
-  private _orderBy: { column: string; direction: 'asc' | 'desc' }[];
-  private _limit?: number;
-  private _offset?: number;
-  private _select: string[];
-  private _withRelations: string[];
   constructor(definition: TDef);
-  where<K extends ColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown), value?: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
-  orWhere<K extends ColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown), value?: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
+  where<K extends ColumnName<TDef>>(column: K, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
+  where<K extends ColumnName<TDef>>(column: K, operator: WhereOperator, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
+  where<K extends ColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | unknown, value?: unknown): ModelQueryBuilder<TDef, TSelected>;
+  orWhere<K extends ColumnName<TDef>>(column: K, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
+  orWhere<K extends ColumnName<TDef>>(column: K, operator: WhereOperator, value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown): ModelQueryBuilder<TDef, TSelected>;
+  orWhere<K extends ColumnName<TDef>>(column: K, operatorOrValue: WhereOperator | unknown, value?: unknown): ModelQueryBuilder<TDef, TSelected>;
   whereIn<K extends ColumnName<TDef>>(column: K, values: (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]): ModelQueryBuilder<TDef, TSelected>;
   whereNotIn<K extends ColumnName<TDef>>(column: K, values: (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]): ModelQueryBuilder<TDef, TSelected>;
   whereNull<K extends ColumnName<TDef>>(column: K): ModelQueryBuilder<TDef, TSelected>;
   whereNotNull<K extends ColumnName<TDef>>(column: K): ModelQueryBuilder<TDef, TSelected>;
   whereLike<K extends ColumnName<TDef>>(column: K, pattern: string): ModelQueryBuilder<TDef, TSelected>;
+  whereBetween<K extends ColumnName<TDef>>(column: K, range: [min: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown, max: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown]): ModelQueryBuilder<TDef, TSelected>;
+  whereNotBetween<K extends ColumnName<TDef>>(column: K, range: [min: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown, max: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown]): ModelQueryBuilder<TDef, TSelected>;
+  when(condition: unknown, callback: (builder: ModelQueryBuilder<TDef, TSelected>) => ModelQueryBuilder<TDef, TSelected>): ModelQueryBuilder<TDef, TSelected>;
   orderBy<K extends ColumnName<TDef>>(column: K, direction?: 'asc' | 'desc'): ModelQueryBuilder<TDef, TSelected>;
   orderByDesc<K extends ColumnName<TDef>>(column: K): ModelQueryBuilder<TDef, TSelected>;
   orderByAsc<K extends ColumnName<TDef>>(column: K): ModelQueryBuilder<TDef, TSelected>;
@@ -223,22 +256,37 @@ declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends
   take(count: number): ModelQueryBuilder<TDef, TSelected>;
   offset(count: number): ModelQueryBuilder<TDef, TSelected>;
   skip(count: number): ModelQueryBuilder<TDef, TSelected>;
-  select<K extends ColumnName<TDef>>(columns: K[]): ModelQueryBuilder<TDef, K>;
-  with<R extends InferRelationNames<TDef>>(relations: R[]): ModelQueryBuilder<TDef, TSelected>;
+  select<K extends ColumnName<TDef>>(...columns: K[]): ModelQueryBuilder<TDef, K>;
+  with<R extends InferRelationNames<TDef>>(...relations: R[]): ModelQueryBuilder<TDef, TSelected>;
   getWithRelations(): string[];
-  private buildQuery(): { sql: string; params: unknown[] };
+  toSql(): { sql: string; params: unknown[] };
   get(): ModelInstance<TDef, TSelected>[];
   first(): ModelInstance<TDef, TSelected> | undefined;
   firstOrFail(): ModelInstance<TDef, TSelected>;
   last(): ModelInstance<TDef, TSelected> | undefined;
   count(): number;
   exists(): boolean;
-  paginate(page?: any, perPage?: any): void;
+  doesntExist(): boolean;
+  sole(): ModelInstance<TDef, TSelected>;
+  increment<K extends NumericColumns<TDef>>(column: K, amount?: number): number;
+  decrement<K extends NumericColumns<TDef>>(column: K, amount?: number): number;
+  chunk(size: number, callback: (items: ModelInstance<TDef, TSelected>[]) => void | false): void;
+  paginate(page?: number, perPage?: number): {
+    data: ModelInstance<TDef, TSelected>[]
+    total: number
+    page: number
+    perPage: number
+    lastPage: number
+    hasMorePages: boolean
+    isEmpty: boolean
+    from: number | null
+    to: number | null
+  };
   pluck<K extends ColumnName<TDef>>(column: K): (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[];
-  max<K extends AttributeKeys<TDef>>(column: K): number;
-  min<K extends AttributeKeys<TDef>>(column: K): number;
-  avg<K extends AttributeKeys<TDef>>(column: K): number;
-  sum<K extends AttributeKeys<TDef>>(column: K): number;
+  max<K extends ColumnName<TDef>>(column: K): number;
+  min<K extends ColumnName<TDef>>(column: K): number;
+  avg<K extends NumericColumns<TDef>>(column: K): number;
+  sum<K extends NumericColumns<TDef>>(column: K): number;
   delete(): number;
   update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): number;
-}
+}

package/dist/schema.d.ts

@@ -28,6 +28,13 @@ export declare function defineModel<const T extends ModelDefinition>(model: T):
  * ```
  */
 export declare function defineModels<const T extends ModelRecord>(models: T): T;
+export declare interface ForeignKeyConfig {
+  table: string
+  column?: string
+  onDelete?: OnForeignKeyAction
+  onUpdate?: OnForeignKeyAction
+  nullable?: boolean
+}
 /**
  * # `Attribute`
  *
@@ -51,6 +58,7 @@ export declare interface Attribute {
   hidden?: boolean
   fillable?: boolean
   guarded?: boolean
+  foreignKey?: boolean | ForeignKeyConfig
   factory?: (faker: Faker) => any
   validation: {
     rule: ValidationType
@@ -58,7 +66,7 @@ export declare interface Attribute {
   }
 }
 export declare interface AttributesElements {
-
+  [key: string]: Attribute
 }
 /**
  * # `CompositeIndex`
@@ -74,9 +82,7 @@ export declare interface CompositeIndex {
   name: string
   columns: string[]
 }
-export declare interface Base {
-
-}
+export declare interface Base {}
 /**
  * # `ModelOptions`
  *
@@ -131,40 +137,41 @@ export declare interface ModelOptions extends Base {
  *
  * Map of field identifiers to custom error messages returned by validators.
  */
-export type ValidatorMessage = Record<string, string>
+export type ValidatorMessage = Record<string, string>;
+export type OnForeignKeyAction = 'cascade' | 'set null' | 'restrict' | 'no action';
 /**
  * # `ValidationType`
  *
  * External validator rule type (compatible with ts-validation). Kept broad to
  * avoid a hard dependency while still enabling type inference via rule shape.
  */
-export type ValidationType = unknown
-export type ModelNames = string
+export type ValidationType = unknown;
+export type ModelNames = string;
 /**
  * # Relationship helpers
  *
  * Lightweight relationship declarations for model definitions. Each helper is a
  * record keyed by relation name with the related model name as value.
  */
-export type HasOne<T extends string> = Record<string, T>
-export type HasMany<T extends string> = Record<string, T>
-export type BelongsTo<T extends string> = Record<string, T>
-export type BelongsToMany<T extends string> = Record<string, T>
-export type HasOneThrough<T extends string> = Record<string, { through: T, target: T }>
-export type HasManyThrough<T extends string> = Record<string, { through: T, target: T }>
-export type MorphOne<T extends string> = Record<string, T>
-export type MorphMany<T extends string> = Record<string, T>
-export type MorphTo = Record<string, unknown>
-export type MorphToMany<T extends string> = Record<string, T>
-export type MorphedByMany<T extends string> = Record<string, T>
-export type ModelDefinition = Readonly<ModelOptions>
+export type HasOne<T extends string> = Record<string, T>;
+export type HasMany<T extends string> = Record<string, T>;
+export type BelongsTo<T extends string> = Record<string, T>;
+export type BelongsToMany<T extends string> = Record<string, T>;
+export type HasOneThrough<T extends string> = Record<string, { through: T, target: T }>;
+export type HasManyThrough<T extends string> = Record<string, { through: T, target: T }>;
+export type MorphOne<T extends string> = Record<string, T>;
+export type MorphMany<T extends string> = Record<string, T>;
+export type MorphTo = Record<string, unknown>;
+export type MorphToMany<T extends string> = Record<string, T>;
+export type MorphedByMany<T extends string> = Record<string, T>;
+export type ModelDefinition = Readonly<ModelOptions>;
 /**
  * # `ModelRecord`
  *
  * Collection of models keyed by model name. Kept flexible to preserve literal
  * attribute keys and value types.
  */
-export type ModelRecord = Record<string, any>
+export type ModelRecord = Record<string, any>;
 /**
  * # `InferAttributes<M>`
  *
@@ -177,12 +184,12 @@ declare type ExtractRuleInput<R> = R extends { validate: (value: infer T) => any
     ? T
     : R extends { getRules: () => Array<{ test: (value: infer T) => any }> }
       ? T
-      : unknown
+      : unknown;
 export type InferAttributes<M extends ModelDefinition> = M extends {
   attributes: infer A extends Record<string, { validation: { rule: any } }>
 }
   ? { [K in keyof A & string]: ExtractRuleInput<A[K]['validation']['rule']> }
-  : Record<string, unknown>
+  : Record<string, unknown>;
 /**
  * # `InferPrimaryKey<M>`
  *
@@ -192,7 +199,7 @@ export type InferPrimaryKey<M extends ModelDefinition> = M extends {
   primaryKey: infer K extends string
 }
   ? K
-  : 'id'
+  : 'id';
 /**
  * # `InferTableName<M>`
  *
@@ -205,7 +212,7 @@ export type InferTableName<M extends ModelDefinition> = M extends {
   ? T
   : M extends { name: infer N extends string }
     ? `${Lowercase<N>}s`
-    : string
+    : string;
 /**
  * # `DatabaseSchema<Models>`
  *
@@ -224,4 +231,4 @@ export type DatabaseSchema<MRecord extends ModelRecord> = {
     columns: InferAttributes<MRecord[MName]>
     primaryKey: InferPrimaryKey<MRecord[MName]>
   };
-}
+}

package/dist/seeder.d.ts

@@ -23,4 +23,6 @@ export declare interface RunSeederOptions {
  */
 export declare abstract class Seeder {
   abstract run(qb: any): Promise<void>;
-}
+  get order(): number;
+  get description(): string | undefined;
+}