bun-query-builder 0.1.44 → 0.1.45

package/dist/bin/cli.js

@@ -26005,7 +26005,7 @@ class ModelQueryBuilder {
     return (await exec.run(sql2, params)).changes;
   }
 }
-function createModel(definition) {
+function createModelInternal(definition) {
   const model = {
     query: () => new ModelQueryBuilder(definition),
     where(column, operatorOrValue, value) {
@@ -26150,6 +26150,9 @@ function createModel(definition) {
     }
   });
 }
+function createModel(definition) {
+  return createModelInternal(definition);
+}
 async function createTableFromModel(definition) {
   const exec = getExecutor();
   const pk = definition.primaryKey || "id";
@@ -30898,7 +30901,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.44";
+var version2 = "0.1.45";
 
 // bin/cli.ts
 init_actions();

package/dist/browser.d.ts

@@ -59,9 +59,9 @@ export declare function createBrowserModel<const TDef extends BrowserModelDefini
  * @defaultValue
  * ```ts
  * {
- *   login: (credentials?: { email: string, password: string }): Promise<BrowserAuthResponse> {
+ *   login: (credentials?: { email: string, password: string }): Promise<{ user: Record<string, unknown>, token: string }> {
  *     const response) => Promise<unknown>,
- *   register: (data?: { name: string, email: string, password: string }): Promise<BrowserAuthResponse> {
+ *   register: (data?: { name: string, email: string, password: string }): Promise<{ user: Record<string, unknown>, token: string }> {
  *     const response) => Promise<unknown>,
  *   logout: () => unknown,
  *   user: () => unknown,
@@ -73,11 +73,11 @@ export declare const browserAuth: {
   /**
    * Login and store token
    */
-  login: (credentials: { email: string, password: string }) => Promise<BrowserAuthResponse>;
+  login: (credentials: { email: string, password: string }) => Promise<;
   /**
    * Register a new user
    */
-  register: (data: { name: string, email: string, password: string }) => Promise<BrowserAuthResponse>;
+  register: (data: { name: string, email: string, password: string }) => Promise<;
   /**
    * Logout and clear token
    */
@@ -170,18 +170,6 @@ declare interface QueryState {
   selectColumns: string[]
   withRelations: string[]
 }
-/**
- * Response shape returned by `browserAuth.login` / `browserAuth.register`.
- * Lifted to a named type so the generated `.d.ts` doesn't carry a nested
- * inline object literal in the return position — bun-plugin-dtsx has a
- * bug where `Promise<{ ... }>` in that position emits as `Promise<;`,
- * breaking downstream typecheck for any consumer that imports from
- * `bun-query-builder/browser`.
- */
-export declare interface BrowserAuthResponse {
-  user: Record<string, unknown>
-  token: string
-}
 // Primitive type mappings
 declare type PrimitiveTypeMap = {
   string: string

package/dist/dynamodb-single-table.d.ts

@@ -9,6 +9,7 @@ export declare function createSingleTableManager(config: SingleTableConfig): Sin
  */
 export declare function createRepository<T extends Record<string, any>>(manager: SingleTableManager, entityName: string, options: DynamoDBQueryBuilderOptions): SingleTableRepository<T>;
 /**
+ * Common single table design patterns
  * @defaultValue
  * ```ts
  * {
@@ -16,11 +17,11 @@ export declare function createRepository<T extends Record<string, any>>(manager:
  *   oneToMany: (parentEntity: string,
  *     childEntity: string,
  *     parentIdField?: string,
- *     childIdField?: string,) => OneToManyPattern,
+ *     childIdField?: string,) => { parent: SingleTableEntity, child: SingleTableEntity },
  *   manyToMany: (entityName: string,
  *     relationName: string,
  *     idField?: string,
- *     relatedIdField?: string,) => ManyToManyPattern,
+ *     relatedIdField?: string,) => { entity: SingleTableEntity, relation: SingleTableEntity },
  *   hierarchical: (entityName: string, rootIdField?: string, pathField?: string) => SingleTableEntity
  * }
  * ```
@@ -37,14 +38,20 @@ export declare const SingleTablePatterns: {
    * Parent: PK=PARENT#<parentId>, SK=METADATA
    * Child: PK=PARENT#<parentId>, SK=CHILD#<childId>
    */
-  oneToMany: (parentEntity: string, childEntity: string, parentIdField?: string, childIdField?: string,) => OneToManyPattern;
+  oneToMany: (parentEntity: string,
+    childEntity: string,
+    parentIdField?: string,
+    childIdField?: string,) => ;
   /**
    * Many-to-many relationship pattern using adjacency list
    * Entity: PK=ENTITY#<entityId>, SK=METADATA
    * Relationship: PK=ENTITY#<entityId>, SK=RELATED#<relatedId>
    * Inverse: PK=ENTITY#<relatedId>, SK=RELATED#<entityId> (via GSI)
    */
-  manyToMany: (entityName: string, relationName: string, idField?: string, relatedIdField?: string,) => ManyToManyPattern;
+  manyToMany: (entityName: string,
+    relationName: string,
+    idField?: string,
+    relatedIdField?: string,) => ;
   /**
    * Hierarchical data pattern (e.g., org chart, file system)
    * PK: ROOT#<rootId>
@@ -93,25 +100,6 @@ export declare interface ManyToManyPattern {
   entity: SingleTableEntity
   relation: SingleTableEntity
 }
-/**
- * Common single table design patterns
- */
-/**
- * Result shapes for relationship pattern helpers. Lifted to named
- * interfaces so the generated `.d.ts` doesn't carry an inline object
- * literal in the return position — bun-plugin-dtsx has a bug where
- * `(...) => { ... }` in that position emits as `=> ;`, breaking
- * downstream typecheck for any consumer importing from
- * `bun-query-builder/dynamodb-single-table`.
- */
-export declare interface OneToManyPattern {
-  parent: SingleTableEntity
-  child: SingleTableEntity
-}
-export declare interface ManyToManyPattern {
-  entity: SingleTableEntity
-  relation: SingleTableEntity
-}
 /**
  * Single Table Design Manager
  *

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 // Resolve ambiguous re-exports by explicitly choosing which module's version to use
 export type { WhereOperator } from './browser';
 export type { ModelQueryBuilder } from './dynamodb/index';
-export type { ColumnName } from './client';
+export type { ColumnName, QueryBuilder } from './client';
+export type { ModelRecord } from './schema';
+export type { ModelDefinition as OrmModelDefinition, ModelStatic as OrmModelStatic } from './orm';
 // Re-export the type-inference version of InferRelationNames (supports wrapped models)
 // to resolve the ambiguity with orm.ts's InferRelationNames (which takes raw definitions)
 export type { InferRelationNames } from './type-inference';

package/dist/orm.d.ts

@@ -37,10 +37,8 @@ export declare function configureOrm(options: { database?: string | Database; ve
  * low-level table setup).
  */
 export declare function getDatabase(): Database;
-/**
- * Create a model class from a definition with full type inference
- */
-export declare function createModel<const TDef extends ModelDefinition>(definition: TDef): void;
+/** Create a model class from a definition with full type inference. */
+export declare function createModel<const TDef extends ModelDefinition>(definition: TDef): ModelStatic<TDef>;
 export declare function createTableFromModel(definition: ModelDefinition): Promise<void>;
 export declare function seedModel(definition: ModelDefinition, count?: number, faker?: Record<string, unknown>): Promise<void>;
 // Attribute definition with explicit type
@@ -111,6 +109,7 @@ export declare interface ModelDefinition {
     readonly taggable?: boolean
     readonly categorizable?: boolean
     readonly commentables?: boolean
+    readonly commentable?: boolean
     readonly useActivityLog?: boolean | object
     readonly useSocials?: readonly string[]
   }
@@ -128,11 +127,11 @@ export declare interface ModelDefinition {
   readonly attributes: {
     readonly [key: string]: TypedAttribute<unknown>
   }
-  readonly get?: Record<string, (attributes: Record<string, unknown>) => unknown>
-  readonly set?: Record<string, (attributes: Record<string, unknown>) => unknown>
+  readonly get?: Record<string, (attributes: any) => unknown>
+  readonly set?: Record<string, (attributes: any) => unknown>
   readonly scopes?: Record<string, (value: unknown) => unknown>
   readonly indexes?: readonly object[]
-  readonly dashboard?: { readonly highlight?: boolean | number }
+  readonly dashboard?: { readonly enabled?: boolean; readonly highlight?: boolean | number }
   readonly hooks?: {
     readonly beforeCreate?: (data: Record<string, unknown>) => void | Promise<void>
     readonly afterCreate?: (model: ModelHookInstance) => void | Promise<void>
@@ -179,6 +178,31 @@ declare interface ResolvedRelation {
   pivotModelName?: string
   pivotTimestamps?: boolean
 }
+/**
+ * Overloaded where/orWhere signatures for static model methods.
+ * Object literals cannot have overloaded methods, so we express them as an interface
+ * and intersect with the concrete model object via a type assertion.
+ */
+declare interface StaticWhereOverloads<TDef extends ModelDefinition> {
+  where<K extends ColumnName<TDef>>(
+    column: K,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+  where<K extends ColumnName<TDef>>(
+    column: K,
+    operator: WhereOperator,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+  orWhere<K extends ColumnName<TDef>>(
+    column: K,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+  orWhere<K extends ColumnName<TDef>>(
+    column: K,
+    operator: WhereOperator,
+    value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown
+  ): ModelQueryBuilder<TDef>
+}
 // Binding helper type for SQL queries
 declare type Bindings = SQLQueryBindings[];
 // Primitive type mappings
@@ -193,12 +217,17 @@ declare type PrimitiveTypeMap = {
 declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
   T extends readonly (infer U)[] ? U :
   T extends (infer U)[] ? U :
+  T extends { validate: (value: infer U) => any } ? U :
   unknown;
 // Extract attribute keys from definition
 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 :
+  TAttr extends { factory: (faker: Faker) => infer R }
+    ? [Exclude<R, null | undefined>] extends [never]
+      ? TAttr extends { validation: { rule: infer V } } ? InferType<V> | Extract<R, null | undefined> : R
+      : R
+    : TAttr extends { validation: { rule: infer R } } ? InferType<R> :
   unknown;
 // Build the full attributes type from definition. Columns declared
 // `nullable: true` admit null — mirrors InferAttributes in type-inference.ts.
@@ -207,6 +236,14 @@ declare type InferModelAttributes<TDef extends ModelDefinition> = {
     ? InferAttributeType<TDef['attributes'][K]> | null
     : InferAttributeType<TDef['attributes'][K]>
 }
+declare type SnakeCase<S extends string> = S extends `${infer C}${infer Rest}`
+  ? C extends Lowercase<C>
+    ? `${C}${SnakeCase<Rest>}`
+    : `_${Lowercase<C>}${SnakeCase<Rest>}`
+  : S;
+declare type SnakeCaseAttributes<TDef extends ModelDefinition> = {
+  [K in keyof InferModelAttributes<TDef> & string as SnakeCase<K>]: InferModelAttributes<TDef>[K]
+}
 // System fields added by traits. The primary-key column honors the model's
 // declared `primaryKey` (default 'id') — a custom-pk model exposes THAT
 // column, not a phantom 'id'. Mirrors InferAttributes in type-inference.ts.
@@ -219,9 +256,10 @@ declare type SystemFields<TDef extends ModelDefinition> = { [K in TDef extends {
   (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> & SnakeCaseAttributes<TDef> & SystemFields<TDef>;
 // All valid column names
 declare type ColumnName<TDef extends ModelDefinition> = | AttributeKeys<TDef>
+  | SnakeCase<AttributeKeys<TDef>>
   | (TDef extends { primaryKey: infer PK extends string } ? PK : 'id')
   | (TDef['traits'] extends { useUuid: true } ? 'uuid' : never)
   | (TDef['traits'] extends { useTimestamps: true } ? 'created_at' | 'updated_at' : never)
@@ -238,6 +276,10 @@ declare type HiddenKeys<TDef extends ModelDefinition> = {
 declare type FillableKeys<TDef extends ModelDefinition> = {
   [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { fillable: true } ? K : never
 }[AttributeKeys<TDef>];
+declare type FillableAttributes<TDef extends ModelDefinition> = Partial<Pick<
+  ModelAttributes<TDef>,
+  FillableKeys<TDef> | SnakeCase<FillableKeys<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
@@ -280,6 +322,10 @@ declare type LoadedRelationValue<TDef, R extends string> = 'one' extends Relatio
     : 'many' extends RelationCardinality<TDef, R>
       ? ModelInstance<any, any>[] | undefined
       : ModelInstance<any, any>[] | ModelInstance<any, any> | null | undefined;
+/** A hydrated model instance with its selected columns exposed as proxy properties. */
+export type ModelRecord<TDef extends ModelDefinition, TSelected extends ColumnName<TDef> = ColumnName<TDef>,> = ModelInstance<TDef, TSelected>
+  & Pick<ModelAttributes<TDef>, Extract<TSelected, keyof ModelAttributes<TDef>>>
+  & { [R in InferRelationNames<TDef>]?: LoadedRelationValue<TDef, R> }
 declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'not like' | 'in' | 'not in';
 // --- Dialect-aware execution layer -------------------------------------------
 //
@@ -295,6 +341,66 @@ declare type WhereOperator = '=' | '!=' | '<' | '>' | '<=' | '>=' | 'like' | 'no
 // `selectFrom(...)` builder already uses. Because the network drivers are
 // async-only, every model read/write method now returns a Promise.
 declare type RunResult = { changes: number, lastInsertId: number | bigint | null }
+/** The fully inferred static model API produced from a model definition. */
+export type ModelStatic<TDef extends ModelDefinition> = StaticWhereOverloads<TDef> & {
+  query: () => ModelQueryBuilder<TDef>
+  whereIn: <K extends ColumnName<TDef>>(column: K, values: (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]) => ModelQueryBuilder<TDef>
+  whereNotIn: <K extends ColumnName<TDef>>(column: K, values: (K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]) => ModelQueryBuilder<TDef>
+  whereNull: <K extends ColumnName<TDef>>(column: K) => ModelQueryBuilder<TDef>
+  whereNotNull: <K extends ColumnName<TDef>>(column: K) => ModelQueryBuilder<TDef>
+  whereLike: <K extends ColumnName<TDef>>(column: K, pattern: string) => ModelQueryBuilder<TDef>
+  orderBy: <K extends ColumnName<TDef>>(column: K, direction?: 'asc' | 'desc') => ModelQueryBuilder<TDef>
+  orderByDesc: <K extends ColumnName<TDef>>(column: K) => ModelQueryBuilder<TDef>
+  select: <K extends ColumnName<TDef>>(...columns: K[]) => ModelQueryBuilder<TDef, K>
+  with: <R extends InferRelationNames<TDef>>(...relations: R[]) => ModelQueryBuilder<TDef>
+  limit: (count: number) => ModelQueryBuilder<TDef>
+  take: (count: number) => ModelQueryBuilder<TDef>
+  skip: (count: number) => ModelQueryBuilder<TDef>
+  withTrashed: () => ModelQueryBuilder<TDef>
+  onlyTrashed: () => ModelQueryBuilder<TDef>
+  find: (id: number | string) => Promise<ModelRecord<TDef> | undefined>
+  findOrFail: (id: number | string) => Promise<ModelRecord<TDef>>
+  findMany: (ids: (number | string)[]) => Promise<ModelRecord<TDef>[]>
+  all: () => Promise<ModelRecord<TDef>[]>
+  first: () => Promise<ModelRecord<TDef> | undefined>
+  firstOrFail: () => Promise<ModelRecord<TDef>>
+  last: () => Promise<ModelRecord<TDef> | undefined>
+  count: () => Promise<number>
+  exists: () => Promise<boolean>
+  doesntExist: () => Promise<boolean>
+  paginate: (page?: number, perPage?: number) => Promise<{
+    data: ModelRecord<TDef>[]
+    total: number
+    page: number
+    perPage: number
+    lastPage: number
+    hasMorePages: boolean
+    isEmpty: boolean
+    from: number | null
+    to: number | null
+  }>
+  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>
+  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>
+  create: (data: FillableAttributes<TDef>) => Promise<ModelRecord<TDef>>
+  createMany: (items: FillableAttributes<TDef>[]) => Promise<ModelRecord<TDef>[]>
+  updateOrCreate: (search: Partial<ModelAttributes<TDef>>, data: FillableAttributes<TDef>) => Promise<ModelRecord<TDef>>
+  firstOrCreate: (search: Partial<ModelAttributes<TDef>>, data?: FillableAttributes<TDef>) => Promise<ModelRecord<TDef>>
+  destroy: (id: number | string) => Promise<boolean>
+  remove: (id: number | string) => Promise<boolean>
+  truncate: () => Promise<void>
+  getDefinition: () => TDef
+  getTable: () => string
+  make: (data?: Partial<ModelAttributes<TDef>>) => ModelInstance<TDef>
+  latest: (column?: ColumnName<TDef>) => ModelQueryBuilder<TDef>
+  oldest: (column?: ColumnName<TDef>) => ModelQueryBuilder<TDef>
+  max: <K extends ColumnName<TDef>>(column: K) => Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown) | null>
+  min: <K extends ColumnName<TDef>>(column: K) => Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown) | null>
+  avg: <K extends NumericColumns<TDef>>(column: K) => Promise<number>
+  sum: <K extends NumericColumns<TDef>>(column: K) => Promise<number>
+  pluck: <K extends ColumnName<TDef>>(column: K) => Promise<(K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown)[]>
+} & {
+  [K in AttributeKeys<TDef> as `where${Capitalize<K>}`]: (value: K extends keyof ModelAttributes<TDef> ? ModelAttributes<TDef>[K] : unknown) => ModelQueryBuilder<TDef>
+}
 declare class SqliteExecutor implements OrmExecutor {
   readonly dialect: unknown;
   public readonly sqliteDb: Database;
@@ -332,10 +438,10 @@ declare class ModelInstance<TDef extends ModelDefinition, TSelected extends Colu
   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;
+  fill(data: FillableAttributes<TDef>): this;
   forceFill(data: Partial<InferModelAttributes<TDef>>): this;
   save(): Promise<this>;
-  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): Promise<this>;
+  update(data: FillableAttributes<TDef>): Promise<this>;
   fresh(): Promise<ModelInstance<TDef, TSelected> | null>;
   delete(): Promise<boolean>;
   restore(): Promise<this>;
@@ -421,14 +527,14 @@ declare class ModelQueryBuilder<TDef extends ModelDefinition, TSelected extends
   with<R extends InferRelationNames<TDef>>(...relations: R[]): ModelQueryBuilder<TDef, TSelected>;
   getWithRelations(): string[];
   toSql(): { sql: string; params: unknown[] };
-  get(): Promise<ModelInstance<TDef, TSelected>[]>;
-  first(): Promise<ModelInstance<TDef, TSelected> | undefined>;
-  firstOrFail(): Promise<ModelInstance<TDef, TSelected>>;
-  last(): Promise<ModelInstance<TDef, TSelected> | undefined>;
+  get(): Promise<ModelRecord<TDef, TSelected>[]>;
+  first(): Promise<ModelRecord<TDef, TSelected> | undefined>;
+  firstOrFail(): Promise<ModelRecord<TDef, TSelected>>;
+  last(): Promise<ModelRecord<TDef, TSelected> | undefined>;
   count(): Promise<number>;
   exists(): Promise<boolean>;
   doesntExist(): Promise<boolean>;
-  sole(): Promise<ModelInstance<TDef, TSelected>>;
+  sole(): Promise<ModelRecord<TDef, TSelected>>;
   increment<K extends NumericColumns<TDef>>(column: K, amount?: number): Promise<number>;
   decrement<K extends NumericColumns<TDef>>(column: K, amount?: number): Promise<number>;
   chunk(size: number, callback: (items: ModelInstance<TDef, TSelected>[]) => void | false | Promise<void | false>): Promise<void>;

package/dist/src/index.js

@@ -26005,7 +26005,7 @@ class ModelQueryBuilder {
     return (await exec.run(sql2, params)).changes;
   }
 }
-function createModel(definition) {
+function createModelInternal(definition) {
   const model = {
     query: () => new ModelQueryBuilder(definition),
     where(column, operatorOrValue, value) {
@@ -26150,6 +26150,9 @@ function createModel(definition) {
     }
   });
 }
+function createModel(definition) {
+  return createModelInternal(definition);
+}
 async function createTableFromModel(definition) {
   const exec = getExecutor();
   const pk = definition.primaryKey || "id";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.1.44",
+  "version": "0.1.45",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",