bun-query-builder 0.1.2 → 0.1.6

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>
@@ -9,6 +9,14 @@ export declare interface SchemaMeta {
     hasMany?: Record<string, string>
     belongsTo?: Record<string, string>
     belongsToMany?: Record<string, string>
+    hasOneThrough?: Record<string, { through: string, target: string }>
+    hasManyThrough?: Record<string, { through: string, target: string }>
+    morphOne?: Record<string, string>
+    morphMany?: Record<string, string>
+    morphTo?: Record<string, unknown>
+    morphToMany?: Record<string, string>
+    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,30 +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 safe, additive-only SQL to migrate from a previous plan to a new plan.
- * - Creates new tables
- * - Adds new columns (no drops or type/nullable/default changes)
- * - Adds new foreign keys for newly added columns
- * - Adds new indexes and unique indexes
- *
- * 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
@@ -33,33 +29,37 @@ export declare interface ColumnPlan {
   hasDefault: boolean
   defaultValue?: PrimitiveDefault
   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'
+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
@@ -108,10 +54,13 @@ export declare interface ModelOptions extends Base {
   hasMany?: HasMany<ModelNames> | ModelNames[]
   belongsTo?: BelongsTo<ModelNames> | ModelNames[]
   belongsToMany?: BelongsToMany<ModelNames> | ModelNames[]
-  hasOneThrough?: HasOneThrough<ModelNames> | ModelNames[]
-  morphOne?: MorphOne<ModelNames> | ModelNames
-  morphMany?: MorphMany<ModelNames>[] | ModelNames[]
+  hasOneThrough?: HasOneThrough<ModelNames>
+  hasManyThrough?: HasManyThrough<ModelNames>
+  morphOne?: MorphOne<ModelNames>
+  morphMany?: MorphMany<ModelNames>
   morphTo?: MorphTo
+  morphToMany?: MorphToMany<ModelNames>
+  morphedByMany?: MorphedByMany<ModelNames>
   scopes?: {
     [key: string]: (value: any) => any
   }
@@ -122,99 +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, 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 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

@@ -0,0 +1,21 @@
+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
+}
+export declare interface RunSeederOptions {
+  class?: string
+  verbose?: boolean
+}
+export declare function defineSeeder(seederClass?: new ()): new () => Seeder;