@stacksjs/orm 0.70.23 → 0.70.32

package/dist/src/batch-loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Per-tick batched load against a Stacks model. The model object is the
+ * batch identity — one queue per `model`. Ids posted in the same
+ * microtask are merged into a single `findMany([...])` call.
+ *
+ * @example
+ * ```ts
+ * import { batchLoad } from '@stacksjs/orm'
+ * import User from '~/app/Models/User'
+ *
+ * // Without batching: 100 SELECTs
+ * for (const id of orderUserIds) await User.find(id)
+ *
+ * // With batching: 1 SELECT (`WHERE id IN (1, 2, … 100)`)
+ * await Promise.all(orderUserIds.map(id => batchLoad(User, id)))
+ * ```
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function batchLoad<T extends { findMany?: (ids: any[]) => Promise<any[]>, find?: (id: any) => Promise<any> }, K = number | string>(model: T, key: K): Promise<unknown>;

package/dist/src/db.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Database access re-export
+ *
+ * This module re-exports the db instance from @stacksjs/database
+ * for convenience within the ORM package.
+ */
+export { db } from '@stacksjs/database';

package/dist/src/define-model.d.ts

@@ -0,0 +1,116 @@
+import type { InferRelationNames } from 'bun-query-builder';
+import { createBillableMethods } from './traits/billable';
+import { createCategorizableMethods } from './traits/categorizable';
+import { createCommentableMethods } from './traits/commentable';
+import { createLikeableMethods } from './traits/likeable';
+import { createSoftDeleteMethods } from './traits/soft-deletes';
+import { createTaggableMethods } from './traits/taggable';
+import { createTwoFactorMethods } from './traits/two-factor';
+// Re-export types from bun-query-builder for convenience
+export type { ModelDefinition, InferRelationNames, ModelAttributes, InferModelAttributes, SystemFields, ColumnName, AttributeKeys, FillableKeys, HiddenKeys, ModelInstance, ModelQueryBuilder } from 'bun-query-builder';
+/**
+ * Stacks-enhanced model definition.
+ *
+ * Wraps bun-query-builder's `createModel()` with:
+ * - Event dispatching via `traits.observe`
+ * - Trait methods (billable, taggable, categorizable, commentable, likeable, 2FA)
+ * - Full backward compatibility with generators (migration, routes, dashboard)
+ *
+ * ### Relationships
+ * Each entry in `belongsTo`, `hasMany`, `hasOne`, `belongsToMany`,
+ * `hasOneThrough`, and `hasManyThrough` declares a typed relation
+ * usable via `.with('relationName')`:
+ *
+ * ```ts
+ * defineModel({
+ *   belongsTo: ['Author'],     // ↪ post.author
+ *   hasMany:   ['Comment'],    // ↪ post.comments (lowercase + pluralized)
+ *   hasOne:    ['Cover'],      // ↪ post.cover
+ * })
+ * ```
+ *
+ * After eager loading the related row(s) are reachable as a property
+ * on the instance — `(await Post.with('author').first()).author`.
+ *
+ * @example
+ * ```ts
+ * import { defineModel } from '@stacksjs/orm'
+ * import { schema } from '@stacksjs/validation'
+ *
+ * export default defineModel({
+ *   name: 'Post',
+ *   table: 'posts',
+ *   attributes: {
+ *     title: { type: 'string', fillable: true, validation: { rule: schema.string() } },
+ *     views: { type: 'number', fillable: true, validation: { rule: schema.number() } },
+ *   },
+ *   belongsTo: ['Author'],
+ *   hasMany: ['Tag', 'Category', 'Comment'],
+ *   traits: { useTimestamps: true, useUuid: true },
+ * } as const)
+ *
+ * // Result: Post.where('title', 'test') — 'title' narrowed to valid columns
+ * // Result: Post.with('author') — 'author' narrowed to valid relations
+ * ```
+ */
+export declare function defineModel<const TDef extends ModelDefinition>(definition: TDef): void;
+/**
+ * Normalize a ModelInstance (or array of them, or already-plain row) into
+ * a serialization-ready plain object.
+ *
+ * Resolves the three shapes a Stacks model query can return:
+ *   - ModelInstance (find/first/get)         → calls toJSON() → strips `hidden` attrs
+ *   - Bare attribute bag with `_attributes`  → returns _attributes as-is
+ *   - Plain row (already normalized)         → returns it unchanged
+ *
+ * Use `toAttrs(inst)` in actions instead of `inst._attributes ?? inst` —
+ * the latter pattern silently leaks `hidden: true` fields (e.g. license_plate,
+ * vin, password hashes) into responses.
+ */
+export declare function toAttrs<T = any>(value: any): T;
+/**
+ * Custom caster interface for user-defined attribute transformations.
+ */
+export declare interface CasterInterface {
+  get(value: unknown): unknown
+  set(value: unknown): unknown
+}
+declare interface StacksModelDefinition {
+  name: string
+  table: string
+  primaryKey?: string
+  autoIncrement?: boolean
+  traits?: Record<string, unknown>
+  indexes?: Array<{ name: string, columns: string[] }>
+  casts?: Record<string, CastType | CasterInterface>
+  attributes: {
+    [key: string]: {
+      factory?: (faker: any) => any
+      [key: string]: any
+    }
+  }
+  [key: string]: any
+}
+export declare interface TraitMethods {
+  _taggable?: ReturnType<typeof createTaggableMethods>
+  _categorizable?: ReturnType<typeof createCategorizableMethods>
+  _commentable?: ReturnType<typeof createCommentableMethods>
+  _billable?: ReturnType<typeof createBillableMethods>
+  _likeable?: ReturnType<typeof createLikeableMethods>
+  _twoFactor?: ReturnType<typeof createTwoFactorMethods>
+  _softDeletes?: ReturnType<typeof createSoftDeleteMethods>
+}
+/**
+ * Built-in cast types for model attributes.
+ */
+export type CastType = 'string' | 'number' | 'boolean' | 'json' | 'datetime' | 'date' | 'array' | 'integer' | 'float';
+declare type ModelDefinition = StacksModelDefinition;
+/**
+ * Thrown by `Model.findOrFail(id)` (and other strict lookups) when no row matches.
+ * Callers can `instanceof` against this to distinguish "missing" from other errors.
+ */
+export declare class ModelNotFoundError extends Error {
+  readonly model: string;
+  readonly id: number | string | undefined;
+  constructor(model: string, id?: number | string);
+}

package/dist/src/index.d.ts

@@ -0,0 +1,157 @@
+import '@stacksjs/validation';
+export type { PrunableOptions } from './utils/prunable';
+export type { AuditHelpers } from './traits/audit';
+// Re-export soft-delete option types so user code can `satisfies SoftDeleteOptions`.
+export type { SoftDeleteOptions, SoftDeleteHelpers } from './traits/soft-deletes';
+// Re-export type utilities from bun-query-builder so consumers can infer
+// model types directly from defineModel() definitions
+export type {
+  InferAttributes,
+  InferPrimaryKey,
+  InferRelationNames,
+  InferTableName,
+  ModelDefinition,
+} from 'bun-query-builder';
+export declare const User: unknown;
+// Same lazy-export pattern for the two queue framework models. The CLI
+// commands `buddy queue:status`, `queue:failed`, `queue:flush`,
+// `queue:inspect`, `queue:monitor`, `queue:clear` import them as
+// `import { Job, FailedJob } from '@stacksjs/orm'`. Prefer the userland
+// publication (`app/Models/Job.ts`, dropped in by `buddy publish:model
+// Job`) so projects that customize the queue model — renamed columns,
+// extra observers, custom traits — see their version.
+export declare const Job: unknown;
+export declare const FailedJob: unknown;
+export declare const Activity: unknown;
+export declare const Author: unknown;
+export declare const Campaign: unknown;
+export declare const Cart: unknown;
+export declare const CartItem: unknown;
+export declare const Category: unknown;
+export declare const Comment: unknown;
+export declare const Coupon: unknown;
+export declare const Customer: unknown;
+export declare const DeliveryRoute: unknown;
+export declare const Deployment: unknown;
+export declare const DigitalDelivery: unknown;
+export declare const Driver: unknown;
+export declare const CampaignSend: unknown;
+export declare const EmailList: unknown;
+export declare const EmailListSubscriber: unknown;
+export declare const ErrorModel: unknown;
+export declare const GiftCard: unknown;
+export declare const LicenseKey: unknown;
+export declare const Log: unknown;
+export declare const LoyaltyPoint: unknown;
+export declare const LoyaltyReward: unknown;
+export declare const Manufacturer: unknown;
+export declare const Notification: unknown;
+export declare const Order: unknown;
+export declare const OrderItem: unknown;
+export declare const Page: unknown;
+export declare const Payment: unknown;
+export declare const PaymentMethod: unknown;
+export declare const PaymentProduct: unknown;
+export declare const PaymentTransaction: unknown;
+export declare const Post: unknown;
+export declare const PrintDevice: unknown;
+export declare const Product: unknown;
+export declare const ProductUnit: unknown;
+export declare const ProductVariant: unknown;
+export declare const Receipt: unknown;
+export declare const Release: unknown;
+export declare const Request: unknown;
+export declare const Review: unknown;
+export declare const ShippingMethod: unknown;
+export declare const ShippingRate: unknown;
+export declare const ShippingZone: unknown;
+export declare const SocialPost: unknown;
+export declare const Subscriber: unknown;
+export declare const SubscriberEmail: unknown;
+export declare const Subscription: unknown;
+export declare const Tag: unknown;
+export declare const TaxRate: unknown;
+export declare const Team: unknown;
+export declare const Transaction: unknown;
+export declare const WaitlistProduct: unknown;
+export declare const WaitlistRestaurant: unknown;
+export declare const Websocket: unknown;
+/** Row type for the polymorphic categories table (categorizable trait). */
+export declare interface CategorizableTable {
+  id?: number
+  name: string
+  slug: string
+  description?: string
+  is_active: boolean
+  categorizable_type: string
+  created_at?: string
+  updated_at?: string
+}
+/** Row type for the category-model pivot table (categorizable trait). */
+export declare interface CategorizableModelsTable {
+  id?: number
+  category_id: number
+  categorizable_type: string
+  categorizable_id: number
+  created_at?: string
+  updated_at?: string
+}
+/** Row type for the polymorphic comments table (commentable trait). */
+export declare interface CommentablesTable {
+  id?: number
+  title: string
+  body: string
+  status: string
+  approved_at: number | null
+  rejected_at: number | null
+  commentables_id: number
+  commentables_type: string
+  user_id: number | null
+  created_at?: string
+  updated_at?: string | null
+}
+/** Row type for the polymorphic tags table (taggable trait). */
+export declare interface TaggableTable {
+  id?: number
+  name: string
+  slug: string
+  description?: string
+  is_active: boolean
+  taggable_type: string
+  created_at?: string
+  updated_at?: string
+}
+// The following type utilities are referenced by the framework but are not
+// yet exported by the installed `bun-query-builder` version. Until upstream
+// catches up we ship structural stubs so consumer code still type-checks.
+// These intentionally fall back to `any` to avoid spurious narrowing errors;
+// once `bun-query-builder` exports the real shapes, remove these stubs.
+export type InferFillableAttributes<_M> = any;
+export type InferNumericColumns<_M> = string;
+export type InferColumnNames<_M> = string;
+export type ModelRow<_M> = any;
+export type ModelRowLoose<_M> = any;
+export type ModelCreateData<_M> = any;
+export type ModelCreateDataLoose<_M> = any;
+/** User model row type — inferred from the User model definition. */
+export type UserModel = ModelRowLoose<unknown>;
+/** Data required to create a new User — inferred fillable attributes. */
+export type NewUser = ModelCreateDataLoose<unknown>;
+export * from './utils/prunable';
+export {
+  collectEncryptedAttributes,
+  decryptValue,
+  encryptValue,
+  isEncrypted,
+} from './utils/encrypted';
+// Audit trait public API: setAuditUser is the queue/cron escape hatch for
+// attributing audit rows to a user when there's no current HTTP request.
+export { setAuditUser, createAuditMethods } from './traits/audit';
+export * from './batch-loader';
+export * from './db';
+export * from './subquery';
+export * from './transaction';
+export * from './model-types';
+export * from './types';
+export * from './utils';
+export * from './define-model';

package/dist/src/model-types.d.ts

@@ -0,0 +1,40 @@
+import type { InferModelAttributes, ModelAttributes, ModelDefinition } from 'bun-query-builder';
+/**
+ * Extract the raw ModelDefinition from a defineModel() return value.
+ * Uses the getDefinition() accessor that defineModel() provides.
+ */
+export type Def<T> = T extends { getDefinition: () => infer D extends ModelDefinition } ? D : never;
+/**
+ * Extract foreign key columns from belongsTo relations.
+ * e.g., belongsTo: ['Customer', 'Coupon'] → { customer_id: number, coupon_id: number }
+ */
+export type BelongsToForeignKeys<TDef> = TDef extends { readonly belongsTo: readonly (infer R extends string)[] }
+    ? { [K in R as `${Lowercase<K>}_id`]: number }
+    : {}
+/**
+ * Full database row type: model attributes + system fields (id, uuid, timestamps) + FK columns.
+ *
+ * @example
+ * import type { ModelRow } from '@stacksjs/orm'
+ * import type Post from '../models/Post'
+ * type PostJsonResponse = ModelRow<Post>
+ */
+export type ModelRow<T> = ModelAttributes<Def<T>> & BelongsToForeignKeys<Def<T>>;
+/**
+ * Insertable data type: model attributes + FK columns, all optional.
+ *
+ * @example
+ * import type { NewModelData } from '@stacksjs/orm'
+ * import type Post from '../models/Post'
+ * type NewPost = NewModelData<Post>
+ */
+export type NewModelData<T> = Partial<InferModelAttributes<Def<T>> & BelongsToForeignKeys<Def<T>>>;
+/**
+ * Updateable data type: model attributes + FK columns, all optional.
+ *
+ * @example
+ * import type { UpdateModelData } from '@stacksjs/orm'
+ * import type Post from '../models/Post'
+ * type PostUpdate = UpdateModelData<Post>
+ */
+export type UpdateModelData<T> = Partial<InferModelAttributes<Def<T>> & BelongsToForeignKeys<Def<T>>>;

package/dist/src/subquery.d.ts

@@ -0,0 +1,22 @@
+declare interface WhereCondition<T, V = any> {
+  type: 'and' | 'or'
+  method: 'where' | 'whereIn' | 'whereNull' | 'whereNotNull' | 'whereBetween' | 'whereExists'
+  column: keyof T
+  operator?: Operator
+  value?: V
+  values?: V[] | [V, V]
+  range?: [V, V]
+  callback?: (query: SubqueryBuilder<T>) => void
+}
+export type Operator = '=' | '<' | '>' | '<=' | '>=' | '<>' | '!=' | 'like' | 'not like' | 'in' | 'not in' | 'between' | 'not between' | 'is' | 'is not';
+export declare class SubqueryBuilder<T> {
+  where<V>(column: keyof T, ...args: [V] | [Operator, V]): void;
+  orWhere<V>(column: keyof T, ...args: [V] | [Operator, V]): void;
+  whereIn<V>(column: keyof T, values: V[]): void;
+  whereNotIn<V>(column: keyof T, values: V[]): void;
+  whereNull(column: keyof T): void;
+  whereNotNull(column: keyof T): void;
+  whereBetween<V>(column: keyof T, range: [V, V]): void;
+  whereExists(callback: (query: SubqueryBuilder<T>) => void): void;
+  getConditions(): WhereCondition<T>[];
+}

package/dist/src/traits/audit.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Override the user id attached to subsequent audit rows. Useful in queue
+ * workers, scheduled jobs, and CLI commands where there is no current HTTP
+ * request to extract the user from. Pass `null` to clear the override and
+ * fall back to the request-derived id.
+ *
+ * @example
+ * ```ts
+ * import { setAuditUser } from '@stacksjs/orm'
+ *
+ * // In a queue job that's running on behalf of user 42:
+ * setAuditUser(42)
+ * try { await processOrder(orderId) } finally { setAuditUser(null) }
+ * ```
+ */
+export declare function setAuditUser(id: number | string | null): void;
+/**
+ * Build the public-facing audit helper(s). Right now that's just
+ * `audits(id)` — the rest is wired up via `applyAudit()` which intercepts
+ * the model's write methods.
+ */
+export declare function createAuditMethods(modelName: string): AuditHelpers;
+/**
+ * Wire the audit trait into a model's static surface. Wraps `create`,
+ * `update`, and `delete` so each one writes a `model_audits` row after a
+ * successful operation. Idempotent against the proxy machinery — relies on
+ * the same wrapping pattern used by `applySoftDeletes`.
+ *
+ * Must run AFTER the static-helpers / cast / soft-delete wrappers have
+ * installed their own versions of `create` / `update` / `delete`, so that
+ * we wrap the final composed function rather than something that gets
+ * shadowed later.
+ *
+ * @example
+ * ```ts
+ * // Inside defineModel():
+ * if (definition.traits?.useAudit) {
+ *   applyAudit(baseModel, definition)
+ * }
+ * ```
+ */
+export declare function applyAudit(baseModel: Record<string, unknown>, modelName: string, primaryKey?: string): void;
+export declare interface AuditHelpers {
+  audits: (id: number | string) => Promise<Array<Record<string, unknown>>>
+}

package/dist/src/traits/soft-deletes.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Build the runtime methods backing the soft-delete trait. The trait is
+ * applied via `applySoftDeletes()` in `define-model.ts`.
+ *
+ * @example
+ * ```ts
+ * const helpers = createSoftDeleteMethods(model, 'id')
+ * await helpers.softDelete(42)
+ * ```
+ */
+export declare function createSoftDeleteMethods(model: SoftDeleteCapableModel, primaryKey?: string): SoftDeleteHelpers;
+/**
+ * Convert `traits.useSoftDeletes` into a normalized options object. The
+ * trait accepts either `true` (legacy) or `{ cascade: [...] }` (new), so
+ * downstream code should always go through this resolver.
+ *
+ * @example
+ * ```ts
+ * resolveSoftDeleteOptions(true)                       // → {}
+ * resolveSoftDeleteOptions({ cascade: ['posts'] })     // → { cascade: ['posts'] }
+ * ```
+ */
+export declare function resolveSoftDeleteOptions(value: unknown): SoftDeleteOptions;
+/**
+ * Run cascade soft-delete (or restore) for every relation listed in
+ * `options.cascade`. Called by `define-model.ts` immediately after the
+ * parent's own soft-delete or restore succeeds.
+ *
+ * IMPORTANT: cascade is fire-and-forget on the audit/observer side — this
+ * function awaits each child to ensure ordering (parent before children
+ * for delete, vice versa for restore) but does not propagate child
+ * failures up to the caller. The parent operation has already committed.
+ *
+ * @example
+ * ```ts
+ * await cascadeSoftDelete(parentDefinition, options, parentId, 'softDelete')
+ * ```
+ */
+export declare function cascadeSoftDelete(parentDefinition: { name: string, hasMany?: ReadonlyArray<string>, hasOne?: ReadonlyArray<string> }, options: SoftDeleteOptions, parentId: number | string, action: 'softDelete' | 'restore'): Promise<void>;
+declare interface SoftDeleteCapableModel {
+  where: (...args: unknown[]) => any
+  query?: () => any
+  delete?: (...args: unknown[]) => unknown
+}
+/**
+ * Object-form options for `traits.useSoftDeletes`.
+ *
+ * @example
+ * ```ts
+ * traits: {
+ *   useSoftDeletes: {
+ *     // Names of relations declared on this model (hasMany / hasOne)
+ *     // that should be soft-deleted alongside the parent.
+ *     cascade: ['posts', 'comments'],
+ *   },
+ * }
+ * ```
+ */
+export declare interface SoftDeleteOptions {
+  cascade?: ReadonlyArray<string>
+}
+export declare interface SoftDeleteHelpers {
+  softDelete: (id: number | string) => Promise<boolean>
+  restore: (id: number | string) => Promise<boolean>
+  forceDelete: (id: number | string) => Promise<boolean>
+  withTrashed: () => any
+  onlyTrashed: () => any
+}

package/dist/src/transaction.d.ts

@@ -0,0 +1,67 @@
+import { db } from '@stacksjs/database';
+/**
+ * Execute a callback within a database transaction.
+ *
+ * The transaction will automatically commit if the callback succeeds,
+ * or rollback if an error is thrown.
+ *
+ * @example
+ * ```ts
+ * await transaction(async (tx) => {
+ *   await tx.insertInto('users').values({ name: 'Alice' }).execute()
+ *   await tx.insertInto('profiles').values({ user_id: 1 }).execute()
+ * })
+ * ```
+ */
+export declare function transaction<T>(callback: (tx: TransactionHandle) => Promise<T>, options?: TransactionOptions): Promise<T>;
+/**
+ * Legacy alias for transaction()
+ * @deprecated Use transaction() instead
+ */
+export declare function transactionBuilder(callback: () => Promise<void>): Promise<void>;
+/**
+ * Create a savepoint within a transaction for nested rollback support.
+ *
+ * @example
+ * ```ts
+ * await transaction(async (tx) => {
+ *   await tx.insertInto('users').values({ name: 'Bob' }).execute()
+ *
+ *   await savepoint(async (sp) => {
+ *     await sp.insertInto('logs').values({ action: 'created' }).execute()
+ *     // If this fails, only this savepoint rolls back
+ *   })
+ * })
+ * ```
+ */
+export declare function savepoint<T>(callback: (sp: TransactionHandle) => Promise<T>): Promise<T>;
+/**
+ * Wrap a function to automatically run within a transaction when called.
+ *
+ * @example
+ * ```ts
+ * const createUserWithProfile = transactional(async (tx, name: string, bio: string) => {
+ *   const user = await tx.insertInto('users').values({ name }).returningAll().executeTakeFirst()
+ *   await tx.insertInto('profiles').values({ user_id: user.id, bio }).execute()
+ *   return user
+ * })
+ *
+ * // Usage - automatically wrapped in transaction
+ * const user = await createUserWithProfile('Alice', 'Hello world')
+ * ```
+ */
+export declare function transactional<TArgs extends any[], R>(fn: (tx: TransactionHandle, ...args: TArgs) => Promise<R>, options?: TransactionOptions): (...args: TArgs) => Promise<R>;
+export declare interface TransactionOptions {
+  retries?: number
+  isolation?: 'read committed' | 'repeatable read' | 'serializable'
+  readOnly?: boolean
+  onRollback?: (error: any) => void
+  afterRollback?: () => void
+}
+/**
+ * Transaction handle. Aliases the project's `db` type so callers get
+ * the same fluent query API inside the callback as outside, without
+ * the previous untyped `(tx: any)` signature that erased intellisense
+ * and let typo'd column names slip through to runtime.
+ */
+export type TransactionHandle = typeof db;

package/dist/src/types.d.ts

@@ -0,0 +1,55 @@
+import type { Operator } from './subquery';
+export declare interface OrmDriver<T = unknown> {
+  find: (id: number) => Promise<T | undefined>
+  create: (data: Partial<T>) => Promise<T>
+  update: (id: number, data: Partial<T>) => Promise<T | undefined>
+  delete: (id: number) => Promise<boolean>
+  all: () => Promise<T[]>
+  where: (column: string, value: unknown) => Promise<T[]>
+}
+export declare interface SelectedQuery<TTable, TJson, K extends string> {
+  where<V = string>(column: keyof TTable, ...args: [V] | [Operator, V]): SelectedQuery<TTable, TJson, K>
+  orWhere(...conditions: [keyof TTable, any][]): SelectedQuery<TTable, TJson, K>
+  whereIn<V = number>(column: keyof TTable, values: V[]): SelectedQuery<TTable, TJson, K>
+  whereNotIn<V = number>(column: keyof TTable, values: V[]): SelectedQuery<TTable, TJson, K>
+  whereBetween<V = number>(column: keyof TTable, range: [V, V]): SelectedQuery<TTable, TJson, K>
+  whereRef(column: keyof TTable, ...args: string[]): SelectedQuery<TTable, TJson, K>
+  when(condition: boolean, callback: (query: SelectedQuery<TTable, TJson, K>) => SelectedQuery<TTable, TJson, K>): SelectedQuery<TTable, TJson, K>
+  whereNull(column: keyof TTable): SelectedQuery<TTable, TJson, K>
+  whereNotNull(column: keyof TTable): SelectedQuery<TTable, TJson, K>
+  whereLike(column: keyof TTable, value: string): SelectedQuery<TTable, TJson, K>
+  orderBy(column: keyof TTable, order: 'asc' | 'desc'): SelectedQuery<TTable, TJson, K>
+  orderByAsc(column: keyof TTable): SelectedQuery<TTable, TJson, K>
+  orderByDesc(column: keyof TTable): SelectedQuery<TTable, TJson, K>
+  groupBy(column: keyof TTable): SelectedQuery<TTable, TJson, K>
+  having<V = string>(column: keyof TTable, operator: Operator, value: V): SelectedQuery<TTable, TJson, K>
+  inRandomOrder(): SelectedQuery<TTable, TJson, K>
+  whereColumn(first: keyof TTable, operator: Operator, second: keyof TTable): SelectedQuery<TTable, TJson, K>
+  skip(count: number): SelectedQuery<TTable, TJson, K>
+  take(count: number): SelectedQuery<TTable, TJson, K>
+  distinct(column: keyof TJson): SelectedQuery<TTable, TJson, K>
+  join(table: string, firstCol: string, secondCol: string): SelectedQuery<TTable, TJson, K>
+  first(): Promise<SelectedResult<TJson, K> | undefined>
+  last(): Promise<SelectedResult<TJson, K> | undefined>
+  firstOrFail(): Promise<SelectedResult<TJson, K>>
+  find(id: number): Promise<SelectedResult<TJson, K> | undefined>
+  findOrFail(id: number): Promise<SelectedResult<TJson, K>>
+  findMany(ids: number[]): Promise<SelectedResult<TJson, K>[]>
+  all(): Promise<SelectedResult<TJson, K>[]>
+  get(): Promise<SelectedResult<TJson, K>[]>
+  latest(column?: keyof TTable): Promise<SelectedResult<TJson, K> | undefined>
+  oldest(column?: keyof TTable): Promise<SelectedResult<TJson, K> | undefined>
+  paginate(options?: { limit?: number, offset?: number, page?: number }): Promise<{
+    data: SelectedResult<TJson, K>[]
+    paging: { total_records: number, page: number, total_pages: number }
+    next_cursor: number | null
+  }>
+  chunk(size: number, callback: (models: SelectedResult<TJson, K>[]) => Promise<void>): Promise<void>
+  pluck<PK extends Extract<K | 'id', keyof TJson>>(field: PK): Promise<TJson[PK][]>
+  max(field: keyof TTable): Promise<number>
+  min(field: keyof TTable): Promise<number>
+  avg(field: keyof TTable): Promise<number>
+  sum(field: keyof TTable): Promise<number>
+  count(): Promise<number>
+}
+export type SelectedResult<TJson, K extends string> = Pick<TJson, Extract<K | 'id', keyof TJson>> & { id: number }