bun-query-builder 0.1.5 → 0.1.6

package/dist/index.js

@@ -28,7 +28,7 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 var __require = import.meta.require;
 
-// ../../node_modules/bunfig/dist/index.js
+// ../../node_modules/.bun/bunfig@0.15.0/node_modules/bunfig/dist/index.js
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
 import { dirname as dirname2, resolve as resolve3 } from "path";
@@ -6443,20 +6443,13 @@ __export(exports_migrate, {
 });
 import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync5, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir } from "os";
-import { dirname as dirname5, join as join5 } from "path";
+import { join as join5 } from "path";
 import process13 from "process";
-function findWorkspaceRoot2(startPath) {
-  let currentPath = startPath;
-  while (currentPath !== dirname5(currentPath)) {
-    if (existsSync7(join5(currentPath, "package.json"))) {
-      return currentPath;
-    }
-    currentPath = dirname5(currentPath);
-  }
+function getWorkspaceRoot() {
   return process13.cwd();
 }
-function ensureSqlDirectory() {
-  const sqlDir = getSqlDirectory();
+function ensureSqlDirectory(workspaceRoot) {
+  const sqlDir = getSqlDirectory(workspaceRoot);
   if (!existsSync7(sqlDir)) {
     mkdirSync5(sqlDir, { recursive: true });
     console.log(`-- Created SQL directory: ${sqlDir}`);
@@ -6467,8 +6460,8 @@ async function generateMigration(dir, opts = {}) {
   if (!dir) {
     dir = join5(process13.cwd(), "app/Models");
   }
-  const dialect = String(opts.dialect || config2.dialect || "postgres");
-  const workspaceRoot = findWorkspaceRoot2(dir);
+  const dialect = opts.dialect || config2.dialect || "postgres";
+  const workspaceRoot = getWorkspaceRoot();
   const models = await loadModels({ modelsDir: dir });
   const plan = buildMigrationPlan(models, { dialect });
   const defaultStatePath = join5(dir, `.qb-migrations.${dialect}.json`);
@@ -6522,8 +6515,12 @@ async function generateMigration(dir, opts = {}) {
   await copyModelsToGenerated(dir, workspaceRoot);
   return { sql, sqlStatements, hasChanges, plan };
 }
-async function executeMigration() {
-  const sqlDir = ensureSqlDirectory();
+async function executeMigration(dir) {
+  if (!dir) {
+    dir = join5(process13.cwd(), "app/Models");
+  }
+  const workspaceRoot = getWorkspaceRoot();
+  const sqlDir = ensureSqlDirectory(workspaceRoot);
   const dialect = config2.dialect || "postgres";
   const files = readdirSync3(sqlDir);
   const scriptFiles = files.filter((file2) => file2.endsWith(".sql")).sort();
@@ -6587,9 +6584,9 @@ async function resetDatabase(dir, opts = {}) {
   if (!dir) {
     dir = join5(process13.cwd(), "app/Models");
   }
-  const dialect = String(opts.dialect || "postgres");
+  const dialect = opts.dialect || "postgres";
   const driver = getDialectDriver(dialect);
-  const workspaceRoot = findWorkspaceRoot2(dir);
+  const workspaceRoot = getWorkspaceRoot();
   try {
     const dropMigrationsSql = driver.dropTable("migrations");
     try {
@@ -6675,7 +6672,7 @@ async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
     dir = join5(process13.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(dir);
+    workspaceRoot = getWorkspaceRoot();
   }
   const dialect = String(opts.dialect || "postgres");
   const defaultStatePath = join5(dir, `.qb-migrations.${dialect}.json`);
@@ -6701,7 +6698,7 @@ async function copyModelsToGenerated(dir, workspaceRoot) {
     dir = join5(process13.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(dir);
+    workspaceRoot = getWorkspaceRoot();
   }
   try {
     const generatedDir = join5(workspaceRoot, "generated");
@@ -6728,9 +6725,9 @@ async function copyModelsToGenerated(dir, workspaceRoot) {
 }
 function getSqlDirectory(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(process13.cwd());
+    workspaceRoot = getWorkspaceRoot();
   }
-  return join5(workspaceRoot, "sql");
+  return join5(workspaceRoot, "database", "sql");
 }
 async function createMigrationsTable(qb, dialect) {
   const driver = getDialectDriver(dialect);
@@ -6783,21 +6780,21 @@ var init_migrate_generate = __esm(async () => {
 
 // src/actions/migrate-rollback.ts
 import { existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname6, join as join6 } from "path";
+import { dirname as dirname5, join as join6 } from "path";
 import process14 from "process";
-function findWorkspaceRoot3(startPath) {
+function findWorkspaceRoot2(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname6(currentPath)) {
+  while (currentPath !== dirname5(currentPath)) {
     if (existsSync8(join6(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname6(currentPath);
+    currentPath = dirname5(currentPath);
   }
   return process14.cwd();
 }
 function getSqlDirectory2(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot3(process14.cwd());
+    workspaceRoot = findWorkspaceRoot2(process14.cwd());
   }
   return join6(workspaceRoot, "sql");
 }
@@ -6865,21 +6862,21 @@ var init_migrate_rollback = __esm(async () => {
 
 // src/actions/migrate-status.ts
 import { existsSync as existsSync9, readdirSync as readdirSync5 } from "fs";
-import { dirname as dirname7, join as join7 } from "path";
+import { dirname as dirname6, join as join7 } from "path";
 import process15 from "process";
-function findWorkspaceRoot4(startPath) {
+function findWorkspaceRoot3(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname7(currentPath)) {
+  while (currentPath !== dirname6(currentPath)) {
     if (existsSync9(join7(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname7(currentPath);
+    currentPath = dirname6(currentPath);
   }
   return process15.cwd();
 }
 function getSqlDirectory3(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot4(process15.cwd());
+    workspaceRoot = findWorkspaceRoot3(process15.cwd());
   }
   return join7(workspaceRoot, "sql");
 }
@@ -7314,15 +7311,15 @@ var init_relation_diagram = __esm(async () => {
 
 // src/actions/seed.ts
 import { existsSync as existsSync10, mkdirSync as mkdirSync6, readdirSync as readdirSync8, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname8, join as join11 } from "path";
+import { dirname as dirname7, join as join11 } from "path";
 import process18 from "process";
-function findWorkspaceRoot5(startPath) {
+function findWorkspaceRoot4(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname8(currentPath)) {
+  while (currentPath !== dirname7(currentPath)) {
     if (existsSync10(join11(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname8(currentPath);
+    currentPath = dirname7(currentPath);
   }
   return process18.cwd();
 }
@@ -7356,7 +7353,7 @@ async function loadSeeders(seedersDir) {
   return seeders;
 }
 async function runSeeders(config3 = {}) {
-  const workspaceRoot = findWorkspaceRoot5(process18.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
   const seedersDir = config3.seedersDir || join11(workspaceRoot, "database/seeders");
   const verbose = config3.verbose ?? true;
   if (verbose) {
@@ -7391,7 +7388,7 @@ async function runSeeders(config3 = {}) {
   }
 }
 async function runSeeder(className, options = {}) {
-  const workspaceRoot = findWorkspaceRoot5(process18.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
   const seedersDir = join11(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   if (verbose) {
@@ -7415,7 +7412,7 @@ async function runSeeder(className, options = {}) {
   }
 }
 async function makeSeeder(name) {
-  const workspaceRoot = findWorkspaceRoot5(process18.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
   const seedersDir = join11(workspaceRoot, "database/seeders");
   if (!existsSync10(seedersDir)) {
     mkdirSync6(seedersDir, { recursive: true });
@@ -7479,7 +7476,7 @@ export default class ${className} extends Seeder {
   console.log(`-- \u2713 Created seeder: ${filePath}`);
 }
 async function freshDatabase(options = {}) {
-  const workspaceRoot = findWorkspaceRoot5(process18.cwd());
+  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
   const modelsDir = options.modelsDir || join11(workspaceRoot, "app/Models");
   const seedersDir = options.seedersDir || join11(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
@@ -7542,21 +7539,21 @@ var init_unsafe = __esm(async () => {
 
 // src/actions/validate.ts
 import { existsSync as existsSync11 } from "fs";
-import { dirname as dirname9, join as join12 } from "path";
+import { dirname as dirname8, join as join12 } from "path";
 import process19 from "process";
-function findWorkspaceRoot6(startPath) {
+function findWorkspaceRoot5(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname9(currentPath)) {
+  while (currentPath !== dirname8(currentPath)) {
     if (existsSync11(join12(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname9(currentPath);
+    currentPath = dirname8(currentPath);
   }
   return process19.cwd();
 }
 async function validateSchema(dir) {
   if (!dir) {
-    dir = join12(findWorkspaceRoot6(process19.cwd()), "app/Models");
+    dir = join12(findWorkspaceRoot5(process19.cwd()), "app/Models");
   }
   const dialect = config2.dialect || "postgres";
   console.log("-- Validating Schema");
@@ -7899,21 +7896,21 @@ function buildSchemaMeta(models) {
 
 // src/migrations.ts
 import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname10, join as join13 } from "path";
+import { dirname as dirname9, join as join13 } from "path";
 import process21 from "process";
-function findWorkspaceRoot7(startPath) {
+function findWorkspaceRoot6(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname10(currentPath)) {
+  while (currentPath !== dirname9(currentPath)) {
     if (existsSync12(join13(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname10(currentPath);
+    currentPath = dirname9(currentPath);
   }
   return process21.cwd();
 }
 function ensureSqlDirectory2() {
-  const workspaceRoot = findWorkspaceRoot7(process21.cwd());
-  const sqlDir = join13(workspaceRoot, "sql");
+  const workspaceRoot = findWorkspaceRoot6(process21.cwd());
+  const sqlDir = join13(workspaceRoot, "database", "sql");
   if (!existsSync12(sqlDir)) {
     mkdirSync7(sqlDir, { recursive: true });
     console.log(`-- Created SQL directory: ${sqlDir}`);

package/dist/loader.d.ts

@@ -1,6 +1,7 @@
 import type { ModelRecord } from './schema';
-export declare function loadModels(options: LoadModelsOptions): Promise<ModelRecord>;
+
 export declare interface LoadModelsOptions {
   cwd?: string
   modelsDir: string
-}
+}
+export declare function loadModels(options: LoadModelsOptions): Promise<ModelRecord>;

package/dist/meta.d.ts

@@ -1,5 +1,5 @@
 import type { ModelRecord } from './schema';
-export declare function buildSchemaMeta(models: ModelRecord): SchemaMeta;
+
 export declare interface SchemaMeta {
   modelToTable: Record<string, string>
   tableToModel: Record<string, string>
@@ -18,4 +18,5 @@ export declare interface SchemaMeta {
     morphedByMany?: Record<string, string>
   }>
   scopes?: Record<string, Record<string, (qb: any, value?: any) => any>>
-}
+}
+export declare function buildSchemaMeta(models: ModelRecord): SchemaMeta;

package/dist/migrations.d.ts

@@ -1,33 +1,26 @@
 import type { ModelRecord } from './schema';
 import type { SupportedDialect } from './types';
-export declare function buildMigrationPlan(models: ModelRecord, options: InferenceOptions): MigrationPlan;
-export declare function generateSql(plan: MigrationPlan): string[];
-/**
- * Helper function to convert SQL statements array to a single string (for backward compatibility)
- */
-export declare function generateSqlString(plan: MigrationPlan): string;
-/**
- * Helper function to convert diff SQL statements array to a single string (for backward compatibility)
- */
-export declare function generateDiffSqlString(previous: MigrationPlan | undefined, next: MigrationPlan): string;
-/**
- * Compute a stable hash for a migration plan. Useful for snapshotting.
- */
-export declare function hashMigrationPlan(plan: MigrationPlan): string;
-/**
- * Generate comprehensive SQL to migrate from a previous plan to a new plan.
- * - Creates new tables
- * - Drops removed tables
- * - Adds new columns
- * - Drops removed columns
- * - Adds new indexes
- * - Drops removed indexes
- * - Adds new foreign keys for newly added columns
- *
- * If there is no previous plan or the dialect changed, generates full SQL.
- */
-export declare function generateDiffSql(previous: MigrationPlan | undefined, next: MigrationPlan): string[];
-export declare interface ColumnPlan {
+
+declare function findWorkspaceRoot(startPath: string): string;
+declare function ensureSqlDirectory(): string;
+declare function createMigrationFile(statement: string, fileName: string): boolean;
+export declare type PrimitiveDefault = string | number | boolean | bigint | Date
+
+export type NormalizedColumnType =
+  | 'string'
+  | 'text'
+  | 'boolean'
+  | 'integer'
+  | 'bigint'
+  | 'float'
+  | 'double'
+  | 'decimal'
+  | 'date'
+  | 'datetime'
+  | 'json'
+  | 'enum'
+
+export interface ColumnPlan {
   name: string
   type: NormalizedColumnType
   isPrimaryKey: boolean
@@ -38,33 +31,35 @@ export declare interface ColumnPlan {
   references?: { table: string, column: string }
   enumValues?: string[]
 }
-export declare interface IndexPlan {
+
+export interface IndexPlan {
   name: string
   columns: string[]
   type: 'index' | 'unique'
 }
-export declare interface TablePlan {
+
+export interface TablePlan {
   table: string
   columns: ColumnPlan[]
   indexes: IndexPlan[]
 }
-export declare interface MigrationPlan {
+
+export interface MigrationPlan {
   dialect: SupportedDialect
   tables: TablePlan[]
 }
-export declare interface InferenceOptions {
-  dialect: SupportedDialect
-}
-export type PrimitiveDefault = string | number | boolean | bigint | Date
-export type NormalizedColumnType = | 'string'
-  | 'text'
-  | 'boolean'
-  | 'integer'
-  | 'bigint'
-  | 'float'
-  | 'double'
-  | 'decimal'
-  | 'date'
-  | 'datetime'
-  | 'json'
-  | 'enum'
+declare function guessTypeFromName(columnName: string): NormalizedColumnType | undefined;
+declare function normalizeDefaultValue(value: unknown): PrimitiveDefault | undefined;
+declare function detectEnumFromValidationRule(rule: unknown): string[] | undefined;
+declare function detectTypeFromValidationRule(rule: unknown): NormalizedColumnType | undefined;
+export declare function buildMigrationPlan(models: ModelRecord, options: InferenceOptions): MigrationPlan;
+export declare function generateSql(plan: MigrationPlan): string[];
+export declare function generateSqlString(plan: MigrationPlan): string;
+export declare function generateDiffSqlString(previous: MigrationPlan | undefined, next: MigrationPlan): string;
+export declare function hashMigrationPlan(plan: MigrationPlan): string;
+declare function canonicalize(value: any): any;
+declare function mapTablesByName(tables: TablePlan[]): Record<string, TablePlan>;
+declare function mapColumnsByName(columns: ColumnPlan[]): Record<string, ColumnPlan>;
+declare function columnsAreDifferent(col1: ColumnPlan, col2: ColumnPlan): boolean;
+declare function mapIndexesByKey(indexes: IndexPlan[]): Record<string, IndexPlan>;
+export declare function generateDiffSql(previous: MigrationPlan | undefined, next: MigrationPlan): string[];

package/dist/schema.d.ts

@@ -1,49 +1,8 @@
-/**
- * # `defineModel(model)`
- *
- * Freezes and returns a model definition with strong inference for attributes
- * and options.
- *
- * @example
- * ```ts
- * const Post = defineModel({
- *   name: 'Post',
- *   attributes: {
- *     title: { validation: { rule: {} // isLength({ min: 1 }) } },
- *   },
- * })
- * ```
- */
-export declare function defineModel<const T extends ModelDefinition>(model: T): T;
-/**
- * # `defineModels(models)`
- *
- * Freezes and returns a record of model definitions, preserving literal keys so
- * downstream types (like `DatabaseSchema`) can map model names to table names.
- *
- * @example
- * ```ts
- * const models = defineModels({ User, Post })
- * ```
- */
-export declare function defineModels<const T extends ModelRecord>(models: T): T;
-/**
- * # `Attribute`
- *
- * Describes a model column and its validation/meta options.
- *
- * @example
- * ```ts
- * const User = defineModel({
- *   name: 'User',
- *   attributes: {
- *     email: { validation: { rule: {} // isEmail() }, unique: true },
- *     age: { validation: { rule: {} // isInt({ min: 0 }) }, default: 0 },
- *   }
- * })
- * ```
- */
-export declare interface Attribute {
+export declare type ValidatorMessage = Record<string, string>
+
+export type ValidationType = unknown
+
+export interface Attribute {
   default?: string | number | boolean | Date
   unique?: boolean
   order?: number
@@ -56,46 +15,33 @@ export declare interface Attribute {
     message?: ValidatorMessage
   }
 }
-export declare interface AttributesElements {
 
+export interface AttributesElements {
+  [key: string]: Attribute
 }
-/**
- * # `CompositeIndex`
- *
- * Describes a named multi-column index.
- *
- * @example
- * ```ts
- * { name: 'user_email_unique', columns: ['email'] }
- * ```
- */
-export declare interface CompositeIndex {
+
+export interface CompositeIndex {
   name: string
   columns: string[]
 }
-export declare interface Base {
 
-}
-/**
- * # `ModelOptions`
- *
- * Declarative model definition used to build a typed `DatabaseSchema`.
- *
- * @example
- * ```ts
- * const User = defineModel({
- *   name: 'User',
- *   table: 'users',
- *   primaryKey: 'id',
- *   attributes: {
- *     id: { validation: { rule: {} // isInt() } },
- *     email: { validation: { rule: {} // isEmail() }, unique: true },
- *   },
- *   indexes: [{ name: 'users_email_unique', columns: ['email'] }],
- * })
- * ```
- */
-export declare interface ModelOptions extends Base {
+export interface Base {}
+
+export type ModelNames = string
+
+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 interface ModelOptions extends Base {
   name: string
   description?: string
   table?: string
@@ -125,102 +71,9 @@ export declare interface ModelOptions extends Base {
     [key: string]: (value: any) => any
   }
 }
-/**
- * # `ValidatorMessage`
- *
- * Map of field identifiers to custom error messages returned by validators.
- */
-export type ValidatorMessage = Record<string, string>
-/**
- * # `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
-/**
- * # 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>
-/**
- * # `ModelRecord`
- *
- * Collection of models keyed by model name. Kept flexible to preserve literal
- * attribute keys and value types.
- */
+
 export type ModelRecord = Record<string, any>
-/**
- * # `InferAttributes<M>`
- *
- * Given a `ModelDefinition`, produces a record of attribute names to their
- * inferred input type based on the validator rule shape.
- */
-declare type ExtractRuleInput<R> = R extends { validate: (value: infer T) => any }
-  ? T
-  : R extends { test: (value: infer T) => any }
-    ? T
-    : R extends { getRules: () => Array<{ test: (value: infer T) => any }> }
-      ? T
-      : 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>
-/**
- * # `InferPrimaryKey<M>`
- *
- * Extracts a model's primary key field name, defaulting to `'id'`.
- */
-export type InferPrimaryKey<M extends ModelDefinition> = M extends {
-  primaryKey: infer K extends string
-}
-  ? K
-  : 'id'
-/**
- * # `InferTableName<M>`
- *
- * Resolves the table name from a model: uses `table` when provided, otherwise
- * falls back to a simple pluralized form of the model name.
- */
-export type InferTableName<M extends ModelDefinition> = M extends {
-  table: infer T extends string
-}
-  ? T
-  : M extends { name: infer N extends string }
-    ? `${Lowercase<N>}s`
-    : string
-/**
- * # `DatabaseSchema<Models>`
- *
- * Maps model definitions to a concrete database schema shape containing the
- * table columns and primary key. This is the primary input for the query
- * builder's type-safety.
- *
- * @example
- * ```ts
- * const models = defineModels({ User, Post })
- * type Schema = DatabaseSchema<typeof models>
- * ```
- */
-export type DatabaseSchema<MRecord extends ModelRecord> = {
-  [MName in keyof MRecord & string as InferTableName<MRecord[MName]>]: {
-    columns: InferAttributes<MRecord[MName]>
-    primaryKey: InferPrimaryKey<MRecord[MName]>
-  };
-}
+export declare function defineModel<const T extends ModelDefinition>(model: T): T;
+export declare function defineModels<const T extends ModelRecord>(models: T): T;

package/dist/seeder.d.ts

@@ -1,26 +1,21 @@
-/**
- * Helper function to create a seeder
- */
-export declare function defineSeeder(seederClass: new () => Seeder): new () => Seeder;
-/**
- * Seeder configuration options
- */
+export declare abstract class Seeder {
+  abstract run(qb: any): Promise<void>
+
+  get order(): number {
+    return 100
+  }
+
+  get description(): string | undefined {
+    return undefined
+  }
+}
 export declare interface SeederConfig {
   seedersDir?: string
   seeders?: string[]
   verbose?: boolean
 }
-/**
- * Options for running seeders
- */
 export declare interface RunSeederOptions {
   class?: string
   verbose?: boolean
 }
-/**
- * Base seeder class that all seeders should extend.
- * Provides access to query builder and faker for generating test data.
- */
-export declare abstract class Seeder {
-  abstract run(qb: any): Promise<void>;
-}
+export declare function defineSeeder(seederClass?: new ()): new () => Seeder;