bun-query-builder 0.1.10 → 0.1.12

package/dist/model.d.ts

@@ -0,0 +1,27 @@
+export type { BrowserModelDefinition as ModelDefinition };
+/**
+ * Define an isomorphic model that works in both server and browser.
+ *
+ * In the browser, this creates a model that uses fetch() to call your API.
+ * On the server, this returns the definition for ORM generation AND provides
+ * query methods that work directly with the database.
+ *
+ * @param definition - The model definition
+ * @returns An isomorphic model with query methods
+ */
+export declare function defineModel<const TDef extends BrowserModelDefinition>(definition: TDef): void;
+/**
+ * Register models on the global window.StacksBrowser object.
+ * Call this in your app's entry point to make models available for STX auto-imports.
+ *
+ * @param models - Object mapping model names to model instances
+ *
+ * @example
+ * ```ts
+ * import Trail from './Models/Trail'
+ * import Activity from './Models/Activity'
+ *
+ * registerBrowserModels({ Trail, Activity })
+ * ```
+ */
+export declare function registerBrowserModels(models: Record<string, unknown>): void;

package/dist/orm.d.ts

@@ -0,0 +1,244 @@
+import { Database } from 'bun:sqlite';
+import type { Faker } from 'ts-mocker';
+export type {
+  ModelInstance,
+  ModelQueryBuilder,
+  ModelAttributes,
+  InferModelAttributes,
+  InferAttributeType,
+  SystemFields,
+  ColumnName,
+  AttributeKeys,
+  FillableKeys,
+  HiddenKeys,
+};
+export declare function configureOrm(options: { database?: string | Database; verbose?: boolean }): void;
+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;
+export declare function createTableFromModel(definition: ModelDefinition): void;
+export declare function seedModel(definition: ModelDefinition, count?: number, faker?: any): Promise<void>;
+// Attribute definition with explicit type
+export declare interface TypedAttribute<T = unknown> {
+  type?: T
+  order?: number
+  fillable?: boolean
+  unique?: boolean
+  hidden?: boolean
+  guarded?: boolean
+  nullable?: boolean
+  default?: InferType<T>
+  validation?: {
+    rule: unknown
+    message?: Record<string, string>
+  }
+  factory?: (faker: Faker) => InferType<T>
+}
+// Base model definition
+export declare interface ModelDefinition {
+  name: string
+  table: string
+  primaryKey?: string
+  autoIncrement?: boolean
+  connection?: string
+  traits?: {
+    readonly useUuid?: boolean
+    readonly useTimestamps?: boolean | object
+    readonly timestampable?: boolean | object
+    readonly useSoftDeletes?: boolean | object
+    readonly softDeletable?: boolean | object
+    readonly useSearch?: boolean | {
+      readonly displayable?: readonly string[]
+      readonly searchable?: readonly string[]
+      readonly sortable?: readonly string[]
+      readonly filterable?: readonly string[]
+    }
+    readonly useSeeder?: boolean | {
+      readonly count: number
+    }
+    readonly seedable?: boolean | {
+      readonly count: number
+    }
+    readonly useApi?: boolean | {
+      readonly uri?: string
+      readonly routes?: readonly string[]
+      readonly middleware?: readonly string[]
+    }
+    readonly useAuth?: boolean | {
+      readonly usePasskey?: boolean
+      readonly useTwoFactor?: boolean
+    }
+    readonly authenticatable?: boolean | object
+    readonly observe?: boolean | readonly string[]
+    readonly billable?: boolean
+    readonly likeable?: boolean | object
+    readonly taggable?: boolean
+    readonly categorizable?: boolean
+    readonly commentables?: boolean
+    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 [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>
+  }
+}
+// Binding helper type for SQL queries
+declare type Bindings = SQLQueryBindings[]
+// Primitive type mappings
+declare type PrimitiveTypeMap = {
+  string: string
+  number: number
+  boolean: boolean
+  date: Date
+  json: Record<string, unknown>
+}
+// Infer the actual TS type from attribute type definition
+declare type InferType<T> = T extends keyof PrimitiveTypeMap ? PrimitiveTypeMap[T] :
+  T extends readonly (infer U)[] ? U :
+  T extends (infer U)[] ? 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 :
+  unknown
+// Build the full attributes type from definition
+declare type InferModelAttributes<TDef extends ModelDefinition> = {
+  [K in AttributeKeys<TDef>]: InferAttributeType<TDef['attributes'][K]>
+}
+// 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 } : {})
+// Complete model type
+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 { useSoftDeletes: true } ? 'deleted_at' : never)
+// Hidden fields
+declare type HiddenKeys<TDef extends ModelDefinition> = {
+  [K in AttributeKeys<TDef>]: TDef['attributes'][K] extends { hidden: true } ? K : never
+}[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
+export type InferRelationNames<TDef> = | InferBelongsToNames<TDef>
+  | InferHasManyNames<TDef>
+  | InferHasOneNames<TDef>
+  | InferBelongsToManyNames<TDef>
+  | InferHasOneThroughNames<TDef>
+  | 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];
+  getChanges(): Partial<InferModelAttributes<TDef>>;
+  fill(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
+  forceFill(data: Partial<InferModelAttributes<TDef>>): this;
+  save(): this;
+  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): this;
+  delete(): boolean;
+  refresh(): this;
+  toJSON(): 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>;
+  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>;
+  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>;
+  limit(count: number): ModelQueryBuilder<TDef, TSelected>;
+  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>;
+  getWithRelations(): string[];
+  private buildQuery(): { 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;
+  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;
+  delete(): number;
+  update(data: Partial<Pick<InferModelAttributes<TDef>, FillableKeys<TDef>>>): number;
+}

package/dist/schema.d.ts

@@ -1,3 +1,4 @@
+import type { Faker } from 'ts-mocker';
 /**
  * # `defineModel(model)`
  *
@@ -50,7 +51,7 @@ export declare interface Attribute {
   hidden?: boolean
   fillable?: boolean
   guarded?: boolean
-  factory?: (faker: unknown) => any
+  factory?: (faker: Faker) => any
   validation: {
     rule: ValidationType
     message?: ValidatorMessage

package/dist/types.d.ts

@@ -151,6 +151,21 @@ export declare interface DatabaseConfig {
   url?: string
   port: number
 }
+/**
+ * # `BrowserConfig`
+ *
+ * Configuration for browser mode that uses fetch() API instead of direct database connections.
+ * This enables the query builder to work in browser environments by translating queries to REST API calls.
+ */
+export declare interface BrowserConfig {
+  baseUrl: string
+  getToken?: () => string | null | Promise<string | null>
+  onUnauthorized?: () => void
+  headers?: Record<string, string>
+  timeout?: number
+  transformResponse?: <T>(response: any) => T
+  transformRequest?: <T>(data: T) => any
+}
 /**
  * # `QueryBuilderConfig`
  *
@@ -171,6 +186,7 @@ export declare interface QueryBuilderConfig {
   verbose: boolean
   dialect: SupportedDialect
   database: DatabaseConfig
+  browser?: BrowserConfig
   timestamps: TimestampConfig
   pagination: PaginationConfig
   aliasing: AliasingConfig
@@ -230,5 +246,6 @@ export declare interface UnsafeOptions {
  * - 'postgres': Uses `RANDOM()`, supports JSON operators (e.g. `@>`), `FOR SHARE`, `FOR UPDATE`, CTEs
  * - 'mysql': Uses `RAND()`, shared locks via `LOCK IN SHARE MODE`
  * - 'sqlite': Lightweight engine; some features are limited or emulated
+ * - 'browser': Browser-compatible mode that uses fetch() API calls instead of direct database connections
  */
-export type SupportedDialect = 'postgres' | 'mysql' | 'sqlite'
+export type SupportedDialect = 'postgres' | 'mysql' | 'sqlite' | 'browser'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",
@@ -21,10 +21,22 @@
   ],
   "exports": {
     ".": {
+      "bun": "./src/index.ts",
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./browser": {
+      "bun": "./src/browser.ts",
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./dynamodb": {
+      "bun": "./src/dynamodb/index.ts",
+      "types": "./dist/dynamodb/index.d.ts",
+      "import": "./dist/dynamodb/index.js"
+    },
     "./*": {
+      "bun": "./src/*",
       "import": "./dist/*"
     }
   },
@@ -58,8 +70,8 @@
     "fresh": "bunx rimraf node_modules/ bun.lock && bun i",
     "prepublishOnly": "bun --bun run build && bun run compile:all && bun run zip",
     "test": "bun test",
-    "lint": "bunx --bun eslint .",
-    "lint:fix": "bunx --bun eslint . --fix",
+    "lint": "bunx --bun pickier lint .",
+    "lint:fix": "bunx --bun pickier lint . --fix",
     "changelog": "bunx logsmith --verbose",
     "changelog:generate": "bunx logsmith --output CHANGELOG.md",
     "release": "bun --bun run changelog:generate && bunx --bun bumpx prompt --recursive",
@@ -70,7 +82,8 @@
   },
   "dependencies": {
     "@stacksjs/clapp": "^0.2.0",
-    "@stacksjs/ts-validation": "^0.4.7",
+    "@stacksjs/ts-validation": "^0.4.9",
+    "dynamodb-tooling": "^0.3.2",
     "ts-mocker": "^0.1.5"
   },
   "devDependencies": {
@@ -82,7 +95,7 @@
   "git-hooks": {
     "pre-commit": {
       "staged-lint": {
-        "*.{js,ts,json,yaml,yml,md}": "bunx --bun eslint --fix"
+        "*.{js,ts,json,yaml,yml,md}": "bunx --bun pickier lint --fix"
       }
     },
     "commit-msg": "bunx gitlint --edit .git/COMMIT_EDITMSG"