peta-orm 0.4.0 → 0.4.1

package/README.md

@@ -17,17 +17,16 @@ const page = await Post.query().with("author").orderBy("id", "asc").paginate(1,
 ## Quick Start
 
 ```bash
-bun add peta-orm arktype kysely
-bun add -d kysely-bun-sqlite
+bun add peta-orm arktype kysely @libsql/kysely-libsql @libsql/client
 ```
 
 ```ts
-import { Database } from "bun:sqlite"
-import { BunSqliteDialect } from "kysely-bun-sqlite"
+import { createClient } from "@libsql/client"
+import { LibsqlDialect } from "@libsql/kysely-libsql"
 import { createORM, defineModel, t } from "peta-orm"
 
 const orm = createORM({
-  dialect: new BunSqliteDialect({ database: new Database("my-app.db") }),
+  dialect: new LibsqlDialect({ url: "file:my-app.db" }),
 })
 
 const User = defineModel("users", {
@@ -343,7 +342,7 @@ bun run examples/07-soft-deletes.ts
 
 | Database | Dialect package | Status |
 |----------|----------------|--------|
-| SQLite | `kysely-bun-sqlite` | ✅ Tested |
+| SQLite | `@libsql/kysely-libsql` + `@libsql/client` | ✅ Tested |
 | PostgreSQL | `pg` | ✅ Tested via Docker |
 | MySQL | `mysql2` | ✅ Tested via Docker |
 

package/dist/index.d.mts

@@ -1,6 +1,479 @@
-import { A as PaginatorJson, C as InsertGraphOptions, D as RelationType, E as RelationOptions, M as Database, O as PaginatedResult, S as QueryBuilder, T as Relation, _ as createColumn, a as ModelDefinition, b as Plugin, c as HookCallback, d as createHookManager, f as ModelId, g as ColumnValue, h as ColumnShape, i as ModelConfig, j as createPaginator, k as Paginator, l as HookManager, m as Column, n as Collection, o as ModelInstance, p as ORMLike, r as createCollection, s as Attribute, t as defineModel, u as LifecycleEvent, v as Constraint, w as UpsertGraphOptions, x as createQueryBuilder, y as SchemaConfig } from "./index-BdJnSMYi.mjs";
-import { Dialect } from "kysely";
+import { Dialect, Kysely } from "kysely";
 
+//#region src/lib/kysely.d.ts
+type Database = Kysely<Record<string, never>>;
+//#endregion
+//#region src/pagination/index.d.ts
+interface Paginator {
+  readonly data: Collection;
+  readonly total: number;
+  readonly perPage: number;
+  readonly currentPage: number;
+  readonly lastPage: number;
+  readonly hasMorePages: boolean;
+  readonly hasPages: boolean;
+  readonly firstItem: number;
+  readonly lastItem: number;
+  readonly onFirstPage: boolean;
+  readonly onLastPage: boolean;
+  readonly count: number;
+  map<T>(fn: (item: ModelInstance) => T): T[];
+  toJSON(): PaginatorJson;
+}
+interface PaginatorJson {
+  data: Record<string, unknown>[];
+  total: number;
+  perPage: number;
+  currentPage: number;
+  lastPage: number;
+  hasMorePages: boolean;
+  hasPages: boolean;
+  firstItem: number | null;
+  lastItem: number | null;
+  onFirstPage: boolean;
+  onLastPage: boolean;
+}
+type PaginatedResult = PaginatorJson;
+declare function createPaginator(items: ModelInstance[], total: number, perPage: number, currentPage: number): Paginator;
+//#endregion
+//#region src/relations/base.d.ts
+type RelationType = "hasMany" | "belongsTo" | "hasOne" | "manyToMany" | "hasManyThrough";
+interface RelationOptions {
+  foreignKey?: string;
+  localKey?: string;
+  through?: string;
+  foreignPivotKey?: string;
+  relatedPivotKey?: string;
+  throughForeignKey?: string;
+  throughLocalKey?: string;
+  pivotExtras?: string[];
+}
+interface Relation {
+  readonly type: RelationType;
+  readonly relatedModelClass: ModelDefinition;
+  readonly foreignKey: string;
+  readonly localKey: string;
+  readonly throughTable?: string;
+  readonly foreignPivotKey?: string;
+  readonly relatedPivotKey?: string;
+  readonly throughForeignKey?: string;
+  readonly throughLocalKey?: string;
+  _morphMap?: Record<string, () => ModelDefinition>;
+  _morphType?: string;
+  _morphId?: string;
+  _morphTypeValue?: string;
+  query(parent: ModelInstance): QueryBuilder;
+  addEagerConstraints(query: QueryBuilder, models: ModelInstance[]): void;
+  match(models: ModelInstance[], results: ModelInstance[], relationName: string): void;
+  getResults(parent: ModelInstance): Promise<ModelInstance | ModelInstance[] | null>;
+  loadEager(models: ModelInstance[], relationName: string, constraints?: ((qb: QueryBuilder) => void) | null): Promise<void>;
+}
+//#endregion
+//#region src/relations/graph/types.d.ts
+interface InsertGraphOptions {
+  /** Allow `#id` / `#ref` special properties in the graph */
+  allowRefs?: boolean;
+  /**
+   * If `true`, objects with an `id` property get related (pivot row / FK set)
+   * instead of inserted. Can be an array of relation names to scope.
+   */
+  relate?: boolean | string[];
+  /**
+   * Whitelist of relation paths allowed for this graph operation.
+   * Accepts an array of dotted paths or a Set. If not set, all relations are allowed.
+   * When used via the query builder, the QB's `allowGraph()` set is forwarded automatically.
+   */
+  allowGraph?: string[] | Set<string>;
+}
+interface UpsertGraphOptions extends InsertGraphOptions {
+  /** Unrelate (set FK null / remove pivot) instead of deleting missing items */
+  unrelate?: boolean | string[];
+  /** Prevent deletion for all or specific relation paths */
+  noDelete?: boolean | string[];
+  /** Prevent insertion for all or specific relation paths */
+  noInsert?: boolean | string[];
+  /** Prevent update for all or specific relation paths */
+  noUpdate?: boolean | string[];
+}
+//#endregion
+//#region src/query/types.d.ts
+interface QueryBuilder extends PromiseLike<ModelInstance[]> {
+  execute(): Promise<ModelInstance[]>;
+  collect(): Promise<Collection>;
+  executeTakeFirst(): Promise<ModelInstance | undefined>;
+  executeTakeFirstOrThrow(): Promise<ModelInstance>;
+  find(id: number | string): Promise<ModelInstance | undefined>;
+  findOrFail(id: number | string): Promise<ModelInstance>;
+  first(): Promise<ModelInstance | undefined>;
+  toSQL(): {
+    sql: string;
+    parameters: readonly unknown[];
+  };
+  count(): Promise<number>;
+  sum(column: string): Promise<number>;
+  avg(column: string): Promise<number>;
+  min(column: string): Promise<number>;
+  max(column: string): Promise<number>;
+  withCount(relation: string): QueryBuilder;
+  withSum(relation: string, column: string): QueryBuilder;
+  withAvg(relation: string, column: string): QueryBuilder;
+  withMin(relation: string, column: string): QueryBuilder;
+  withMax(relation: string, column: string): QueryBuilder;
+  withExists(relation: string): QueryBuilder;
+  chunk(size: number, callback: (chunk: ModelInstance[]) => Promise<void>): Promise<void>;
+  paginate(page: number, perPage?: number): Promise<Paginator>;
+  insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
+  upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
+  with(...relations: (string | Record<string, (qb: QueryBuilder) => void>)[]): QueryBuilder;
+  /**
+   * Whitelist allowed relations (and nested paths) for eager loading.
+   * Throws if a relation path is not in the allow list.
+   *
+   * Supports dotted paths for granular control:
+   * - `allowGraph("posts")` allows `posts`, `posts.author`, `posts.author.profile`, etc.
+   * - `allowGraph("posts.author")` allows `posts.author` and `posts.author.profile`,
+   *   but NOT bare `posts` or `posts.comments`.
+   *
+   * Multiple arguments are merged: `allowGraph("posts", "profile")`
+   */
+  allowGraph(...expressions: string[]): QueryBuilder;
+  updateMany(data: Record<string, unknown>): Promise<number>;
+  deleteMany(): Promise<number>;
+  withTrashed(): QueryBuilder;
+  onlyTrashed(): QueryBuilder;
+  whereIn(column: string, values: unknown[]): QueryBuilder;
+  whereInPivot(column: string, values: unknown[]): QueryBuilder;
+  has(relationName: string): QueryBuilder;
+  whereHas(relationName: string, callback?: (qb: QueryBuilder) => void): QueryBuilder;
+  whereDoesntHave(relationName: string, callback?: (qb: QueryBuilder) => void): QueryBuilder;
+  where(column: string, operator: unknown, value?: unknown): QueryBuilder;
+  whereRef(col1: string, operator: string, col2: string): QueryBuilder;
+  orWhere(column: string, operator: unknown, value?: unknown): QueryBuilder;
+  orderBy(column: string, direction?: "asc" | "desc"): QueryBuilder;
+  limit(n: number): QueryBuilder;
+  offset(n: number): QueryBuilder;
+  select(...columns: string[]): QueryBuilder;
+  selectAll(table?: string): QueryBuilder;
+  innerJoin(table: string, lhs: string, rhs: string): QueryBuilder;
+  leftJoin(table: string, lhs: string, rhs: string): QueryBuilder;
+  groupBy(...columns: string[]): QueryBuilder;
+  having(column: string, operator: string, value: unknown): QueryBuilder;
+  withoutGlobalScope(name: string): QueryBuilder;
+  all(): QueryBuilder;
+  /** @internal Access underlying Kysely builder for raw SQL operations */
+  _getKyselyQb(): any;
+  /** @internal Replace the underlying Kysely builder */
+  _replaceKyselyQb(newQb: any): void;
+  when(condition: unknown, callback: (q: QueryBuilder) => QueryBuilder): QueryBuilder;
+  unless(condition: unknown, callback: (q: QueryBuilder) => QueryBuilder): QueryBuilder;
+}
+//#endregion
+//#region src/query/builder.d.ts
+declare function createQueryBuilder(def: ModelDefinition, peta?: {
+  kysely: Database;
+}): QueryBuilder;
+//#endregion
+//#region src/relations/related-query.d.ts
+interface RelationQuery extends QueryBuilder {
+  /** Attach related model(s) for many-to-many relations. */
+  attach(ids: number | number[] | string | string[], pivotData?: Record<string, unknown>): Promise<void>;
+  /** Detach related model(s) for many-to-many relations. */
+  detach(ids?: number | number[] | string | string[]): Promise<void>;
+  /** Sync related models: attaches new IDs, detaches missing ones. */
+  sync(ids: (number | string)[] | Record<number | string, Record<string, unknown>>): Promise<void>;
+  /** Sync without detaching existing IDs. */
+  syncWithoutDetaching(ids: (number | string)[]): Promise<void>;
+  /** Update pivot data for a specific related model. */
+  updateExistingPivot(id: number | string, data: Record<string, unknown>): Promise<void>;
+}
+//#endregion
+//#region src/plugins/index.d.ts
+/**
+ * A plugin is a function that receives a model definition and can
+ * modify it by adding hooks, scopes, columns, or methods.
+ *
+ * ```ts
+ * const myPlugin = (options?: MyOptions): Plugin =>
+ *   (def) => {
+ *     def.addGlobalScope?.('active', (q) => q.where('active', true))
+ *     return def
+ *   }
+ * ```
+ */
+type Plugin = (def: ModelDefinition) => undefined | ModelDefinition;
+//#endregion
+//#region src/columns/schema.d.ts
+interface Constraint {
+  type: string;
+  args: unknown[];
+}
+interface SchemaConfig {
+  compile(dataType: string, args: unknown[], constraints: Constraint[]): unknown;
+  parse<T>(schema: unknown, value: unknown): T;
+  assert<T>(schema: unknown, value: unknown): T;
+}
+//#endregion
+//#region src/columns/column.d.ts
+interface Column<out T = unknown> {
+  readonly arkType: unknown;
+  readonly dataType: string;
+  readonly args: readonly unknown[];
+  readonly constraints: readonly Constraint[];
+  readonly isNullable: boolean;
+  readonly isPrimaryKey: boolean;
+  readonly isUnique: boolean;
+  readonly defaultValue: unknown;
+  hasConstraint(type: string): boolean;
+  parse(value: unknown): T;
+  assert(value: unknown): T;
+  primaryKey(): Column<T>;
+  nullable(): Column<T | null>;
+  default<V>(value: V): Column<T>;
+  unique(): Column<T>;
+  index(): Column<T>;
+  min(n: number): Column<T>;
+  max(n: number): Column<T>;
+  email(): Column<T>;
+  url(): Column<T>;
+  pattern(regex: RegExp | string): Column<T>;
+  references(table: () => unknown, columns: string[]): Column<T>;
+}
+declare function createColumn<T>(schema: SchemaConfig, dataType: string, args?: unknown[], constraints?: Constraint[]): Column<T>;
+type ColumnShape = Record<string, Column>;
+type ColumnValue<C> = C extends Column<infer T> ? T : never;
+//#endregion
+//#region src/types.d.ts
+type ModelId = number & {
+  readonly __brand: "ModelId";
+};
+interface ModelLike {
+  get<T = unknown>(key: string): T;
+  set(key: string, value: unknown): void;
+}
+interface ORMLike {
+  readonly kysely: Database;
+  register(model: ModelDefinition$1<any>): void;
+  registerAll(...models: (ModelDefinition$1<any> | ModelDefinition$1<any>[])[]): void;
+  destroy(): Promise<void>;
+  transaction<T>(fn: (trx: import("kysely").Kysely<Record<string, never>>) => Promise<T>): Promise<T>;
+  readonly models: ReadonlyMap<string, ModelDefinition$1<any>>;
+  getModel<T extends ColumnShape = ColumnShape>(name: string): ModelDefinition$1<T> | undefined;
+}
+interface ModelDefinition$1<TColumns extends ColumnShape = ColumnShape> {
+  readonly table: string;
+  readonly columns: TColumns;
+  readonly relations: Record<string, Relation>;
+  readonly name: string;
+  _orm: ORMLike | null;
+  query(): QueryBuilder;
+  find(id: number | string): Promise<ModelInstance | undefined>;
+  findOrFail(id: number | string): Promise<ModelInstance>;
+  first(): Promise<ModelInstance | undefined>;
+  create(data: Record<string, unknown>): Promise<ModelInstance>;
+  insert(data: Record<string, unknown>): Promise<ModelInstance>;
+  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance[]>;
+  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance>;
+  delete(id: number | string): Promise<void>;
+  hydrate(row: Record<string, unknown>): ModelInstance;
+  on(event: string, callback: (model: ModelInstance) => void | Promise<void>): () => void;
+  getHooks(): HookManager;
+  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
+  removeGlobalScope(name: string): void;
+  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
+  _init(orm: ORMLike): void;
+}
+//#endregion
+//#region src/hooks/index.d.ts
+type LifecycleEvent = "beforeCreate" | "afterCreate" | "beforeUpdate" | "afterUpdate" | "beforeSave" | "afterSave" | "beforeDelete" | "afterDelete" | "beforeRestore" | "afterRestore" | "beforeForceDelete" | "afterForceDelete";
+type HookCallback = (model: ModelLike) => void | Promise<void>;
+interface HookManager {
+  on(event: LifecycleEvent, callback: HookCallback): () => void;
+  off(event: LifecycleEvent, callback: HookCallback): void;
+  trigger(event: LifecycleEvent, model: ModelLike): Promise<void>;
+  clone(): HookManager;
+}
+declare function createHookManager(): HookManager;
+//#endregion
+//#region src/hooks/static.d.ts
+interface StaticHookArgs {
+  /** Transform the mutating query into a SELECT to preview affected rows */
+  asFindQuery(): QueryBuilder;
+  /** Cancel the mutation and return a custom result */
+  cancelQuery(result: unknown): void;
+  /** The column data being inserted/updated (for create/update hooks) */
+  inputItems?: Record<string, unknown>[];
+}
+type StaticHookCallback = (args: StaticHookArgs) => void | Promise<void>;
+//#endregion
+//#region src/model/computed.d.ts
+interface ComputedColumn<T = unknown> {
+  readonly type: "sql" | "runtime" | "batch";
+  readonly dependencies: string[];
+  /** Compute a value for a single record (runtime) */
+  compute?: (record: ModelInstance) => T;
+  /** Compute values for a batch of records (batch async) */
+  batchCompute?: (records: ModelInstance[]) => Promise<T[]>;
+  /** Raw SQL expression to inline in SELECT */
+  sql?: string;
+}
+//#endregion
+//#region src/model/attribute.d.ts
+/**
+ * Defines an accessor (`get`) and/or mutator (`set`) for a model attribute.
+ *
+ * ### Accessor (get)
+ * Transforms the attribute value when read via `model.get()` or `model.$toJSON()`.
+ * Receives the casted value and the model instance.
+ *
+ * ### Mutator (set)
+ * Transforms the attribute value when written via `model.set()`, `model.fill()`,
+ * or during model creation (`Model.insert()` / `Model.create()`).
+ * Receives the raw input value and the model instance, returns the value to store.
+ * Applied **before** type casting.
+ *
+ * ### Usage
+ * ```ts
+ * defineModel('users', {
+ *   columns: { id, name, password, ... },
+ *   attributes: {
+ *     password: Attribute.make({
+ *       set: (value) => Bun.password.hashSync(value, { algorithm: 'bcrypt' }),
+ *       get: () => '***',
+ *     }),
+ *     fullName: Attribute.make({
+ *       get: (_, instance) => `${instance.get('firstName')} ${instance.get('lastName')}`,
+ *     }),
+ *   },
+ * })
+ * ```
+ */
+declare class Attribute<T = any> {
+  readonly get?: ((value: T, instance: ModelInstance) => any) | undefined;
+  readonly set?: ((value: any, instance: ModelInstance) => T) | undefined;
+  private constructor();
+  static make<T = any>(config: {
+    /** Transform the attribute value when read. Receives (castedValue, instance). */get?: (value: T, instance: ModelInstance) => any; /** Transform the attribute value when written. Receives (rawValue, instance), returns value to store. */
+    set?: (value: any, instance: ModelInstance) => T;
+  }): Attribute<T>;
+}
+//#endregion
+//#region src/model/types.d.ts
+interface ModelInstance {
+  readonly exists: boolean;
+  readonly attributes: Record<string, unknown>;
+  readonly dirtyAttributes: Record<string, unknown>;
+  isDirty(key?: string): boolean;
+  get<T = unknown>(key: string): T;
+  set(key: string, value: unknown): void;
+  fill(data: Record<string, unknown>): void;
+  reset(): void;
+  $getRelation<T = unknown>(name: string): T;
+  $setRelation(name: string, value: unknown): void;
+  $hasRelation(name: string): boolean;
+  $relationData(): Record<string, unknown>;
+  $load(...relations: string[]): Promise<void>;
+  $related(name: string): RelationQuery;
+  $save(): Promise<this>;
+  $delete(): Promise<void>;
+  $forceDelete(): Promise<void>;
+  $restore(): Promise<void>;
+  $trashed(): boolean;
+  $reload(): Promise<void>;
+  $toJSON(): Record<string, unknown>;
+  toJSON(): Record<string, unknown>;
+}
+interface ModelDefinition<TColumns extends ColumnShape = ColumnShape> {
+  readonly table: string;
+  readonly columns: TColumns;
+  readonly relations: Record<string, Relation>;
+  readonly name: string;
+  _orm: ORMLike | null;
+  query(): QueryBuilder;
+  find(id: number | string): Promise<ModelInstance | undefined>;
+  findOrFail(id: number | string): Promise<ModelInstance>;
+  first(): Promise<ModelInstance | undefined>;
+  create(data: Record<string, unknown>): Promise<ModelInstance>;
+  insert(data: Record<string, unknown>): Promise<ModelInstance>;
+  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance[]>;
+  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance>;
+  delete(id: number | string): Promise<void>;
+  insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
+  upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
+  hydrate(row: Record<string, unknown>): ModelInstance;
+  use(plugin: Plugin): ModelDefinition;
+  makeHelper<A extends any[], R>(fn: (qb: QueryBuilder, ...args: A) => R): (...args: A) => R;
+  on(event: string, callback: (model: ModelInstance) => void | Promise<void>): () => void;
+  getHooks(): HookManager;
+  beforeDelete(callback: StaticHookCallback): () => void;
+  afterDelete(callback: StaticHookCallback): () => void;
+  beforeUpdate(callback: StaticHookCallback): () => void;
+  afterUpdate(callback: StaticHookCallback): () => void;
+  beforeCreate(callback: StaticHookCallback): () => void;
+  afterCreate(callback: StaticHookCallback): () => void;
+  beforeFind(callback: StaticHookCallback): () => void;
+  afterFind(callback: StaticHookCallback): () => void;
+  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
+  removeGlobalScope(name: string): void;
+  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
+  registerTimestamps?(createdAtCol?: string, updatedAtCol?: string): void;
+  registerSoftDeletes?(deletedAtCol?: string): void;
+  discover?(): Promise<never>;
+  _init(orm: ORMLike): void;
+}
+interface ModelConfig<TColumns extends ColumnShape = ColumnShape> {
+  columns: TColumns;
+  relations?: Record<string, Relation>;
+  casts?: Record<string, string>;
+  /** Per-attribute accessors (`get`) and/or mutators (`set`). See {@link Attribute.make}. */
+  attributes?: Record<string, Attribute<any>>;
+  hidden?: string[];
+  visible?: string[];
+  appends?: string[];
+  computed?: Record<string, ComputedColumn>;
+}
+//#endregion
+//#region src/collection/index.d.ts
+interface Collection {
+  readonly length: number;
+  [Symbol.iterator](): Iterator<ModelInstance>;
+  at(index: number): ModelInstance | undefined;
+  first(): ModelInstance | undefined;
+  last(): ModelInstance | undefined;
+  all(): ModelInstance[];
+  findBy(id: number | string): ModelInstance | undefined;
+  find(callback: (item: ModelInstance, index: number) => boolean): ModelInstance | undefined;
+  some(callback: (item: ModelInstance, index: number) => boolean): boolean;
+  includes(item: ModelInstance): boolean;
+  isEmpty(): boolean;
+  isNotEmpty(): boolean;
+  get(key: string): unknown[];
+  pluck(key: string): unknown[];
+  groupBy(key: string): Record<string, ModelInstance[]>;
+  keyBy(key: string): Record<string, ModelInstance>;
+  map<T>(fn: (item: ModelInstance, index: number) => T): T[];
+  filter(fn: (item: ModelInstance, index: number) => boolean): Collection;
+  reduce<T>(fn: (acc: T, item: ModelInstance, index: number) => T, initial: T): T;
+  forEach(fn: (item: ModelInstance, index: number) => void): void;
+  each(fn: (item: ModelInstance, index: number) => void): Collection;
+  unique(key?: string): Collection;
+  sortBy(key: string, direction?: "asc" | "desc"): Collection;
+  shuffle(): Collection;
+  take(n: number): Collection;
+  skip(n: number): Collection;
+  chunk(size: number): Collection[];
+  sum(key: string): number;
+  avg(key: string): number;
+  min(key: string): number;
+  max(key: string): number;
+  diff(other: Collection): Collection;
+  intersect(other: Collection): Collection;
+  concat(other: Collection): Collection;
+  push(...items: ModelInstance[]): void;
+  load(...relations: string[]): Promise<Collection>;
+  toJSON(): Record<string, unknown>[];
+}
+declare function createCollection(items?: ModelInstance[]): Collection;
+//#endregion
 //#region src/columns/arktype.d.ts
 declare function createArkTypeSchemaConfig(): SchemaConfig;
 //#endregion
@@ -63,6 +536,9 @@ declare class DatabaseError extends Error {
 //#region src/errors/normalizer.d.ts
 declare function normalizeError(e: unknown, table?: string): DatabaseError;
 //#endregion
+//#region src/model/define.d.ts
+declare function defineModel<TColumns extends ColumnShape>(table: string, config: ModelConfig<TColumns>): ModelDefinition<TColumns>;
+//#endregion
 //#region src/orm/index.d.ts
 interface ORMConfig {
   dialect: Dialect;

package/package.json

@@ -2,7 +2,7 @@
   "name": "peta-orm",
   "type": "module",
   "private": false,
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "ORM for Bun, built on Kysely",
   "license": "MIT",
   "repository": {
@@ -16,17 +16,9 @@
     ".": {
       "import": "./dist/index.mjs",
       "types": "./dist/index.d.mts"
-    },
-    "./migrator": {
-      "import": "./dist/migrations/index.mjs",
-      "types": "./dist/migrations/index.d.mts"
     }
   },
-  "bin": {
-    "peta": "./bin/peta"
-  },
   "files": [
-    "bin/",
     "dist/",
     "README.md",
     "LICENSE"

package/bin/peta

@@ -1,3 +0,0 @@
-#!/usr/bin/env bun
-import { run } from "../dist/migrations/cli.mjs"
-await run()

package/dist/index-BdJnSMYi.d.mts

@@ -1,480 +0,0 @@
-import { Kysely } from "kysely";
-
-//#region src/lib/kysely.d.ts
-type Database = Kysely<Record<string, never>>;
-//#endregion
-//#region src/pagination/index.d.ts
-interface Paginator {
-  readonly data: Collection;
-  readonly total: number;
-  readonly perPage: number;
-  readonly currentPage: number;
-  readonly lastPage: number;
-  readonly hasMorePages: boolean;
-  readonly hasPages: boolean;
-  readonly firstItem: number;
-  readonly lastItem: number;
-  readonly onFirstPage: boolean;
-  readonly onLastPage: boolean;
-  readonly count: number;
-  map<T>(fn: (item: ModelInstance) => T): T[];
-  toJSON(): PaginatorJson;
-}
-interface PaginatorJson {
-  data: Record<string, unknown>[];
-  total: number;
-  perPage: number;
-  currentPage: number;
-  lastPage: number;
-  hasMorePages: boolean;
-  hasPages: boolean;
-  firstItem: number | null;
-  lastItem: number | null;
-  onFirstPage: boolean;
-  onLastPage: boolean;
-}
-type PaginatedResult = PaginatorJson;
-declare function createPaginator(items: ModelInstance[], total: number, perPage: number, currentPage: number): Paginator;
-//#endregion
-//#region src/relations/base.d.ts
-type RelationType = "hasMany" | "belongsTo" | "hasOne" | "manyToMany" | "hasManyThrough";
-interface RelationOptions {
-  foreignKey?: string;
-  localKey?: string;
-  through?: string;
-  foreignPivotKey?: string;
-  relatedPivotKey?: string;
-  throughForeignKey?: string;
-  throughLocalKey?: string;
-  pivotExtras?: string[];
-}
-interface Relation {
-  readonly type: RelationType;
-  readonly relatedModelClass: ModelDefinition;
-  readonly foreignKey: string;
-  readonly localKey: string;
-  readonly throughTable?: string;
-  readonly foreignPivotKey?: string;
-  readonly relatedPivotKey?: string;
-  readonly throughForeignKey?: string;
-  readonly throughLocalKey?: string;
-  _morphMap?: Record<string, () => ModelDefinition>;
-  _morphType?: string;
-  _morphId?: string;
-  _morphTypeValue?: string;
-  query(parent: ModelInstance): QueryBuilder;
-  addEagerConstraints(query: QueryBuilder, models: ModelInstance[]): void;
-  match(models: ModelInstance[], results: ModelInstance[], relationName: string): void;
-  getResults(parent: ModelInstance): Promise<ModelInstance | ModelInstance[] | null>;
-  loadEager(models: ModelInstance[], relationName: string, constraints?: ((qb: QueryBuilder) => void) | null): Promise<void>;
-}
-//#endregion
-//#region src/relations/graph/types.d.ts
-interface InsertGraphOptions {
-  /** Allow `#id` / `#ref` special properties in the graph */
-  allowRefs?: boolean;
-  /**
-   * If `true`, objects with an `id` property get related (pivot row / FK set)
-   * instead of inserted. Can be an array of relation names to scope.
-   */
-  relate?: boolean | string[];
-  /**
-   * Whitelist of relation paths allowed for this graph operation.
-   * Accepts an array of dotted paths or a Set. If not set, all relations are allowed.
-   * When used via the query builder, the QB's `allowGraph()` set is forwarded automatically.
-   */
-  allowGraph?: string[] | Set<string>;
-}
-interface UpsertGraphOptions extends InsertGraphOptions {
-  /** Unrelate (set FK null / remove pivot) instead of deleting missing items */
-  unrelate?: boolean | string[];
-  /** Prevent deletion for all or specific relation paths */
-  noDelete?: boolean | string[];
-  /** Prevent insertion for all or specific relation paths */
-  noInsert?: boolean | string[];
-  /** Prevent update for all or specific relation paths */
-  noUpdate?: boolean | string[];
-}
-//#endregion
-//#region src/query/types.d.ts
-interface QueryBuilder extends PromiseLike<ModelInstance[]> {
-  execute(): Promise<ModelInstance[]>;
-  collect(): Promise<Collection>;
-  executeTakeFirst(): Promise<ModelInstance | undefined>;
-  executeTakeFirstOrThrow(): Promise<ModelInstance>;
-  find(id: number | string): Promise<ModelInstance | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance>;
-  first(): Promise<ModelInstance | undefined>;
-  toSQL(): {
-    sql: string;
-    parameters: readonly unknown[];
-  };
-  count(): Promise<number>;
-  sum(column: string): Promise<number>;
-  avg(column: string): Promise<number>;
-  min(column: string): Promise<number>;
-  max(column: string): Promise<number>;
-  withCount(relation: string): QueryBuilder;
-  withSum(relation: string, column: string): QueryBuilder;
-  withAvg(relation: string, column: string): QueryBuilder;
-  withMin(relation: string, column: string): QueryBuilder;
-  withMax(relation: string, column: string): QueryBuilder;
-  withExists(relation: string): QueryBuilder;
-  chunk(size: number, callback: (chunk: ModelInstance[]) => Promise<void>): Promise<void>;
-  paginate(page: number, perPage?: number): Promise<Paginator>;
-  insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
-  upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
-  with(...relations: (string | Record<string, (qb: QueryBuilder) => void>)[]): QueryBuilder;
-  /**
-   * Whitelist allowed relations (and nested paths) for eager loading.
-   * Throws if a relation path is not in the allow list.
-   *
-   * Supports dotted paths for granular control:
-   * - `allowGraph("posts")` allows `posts`, `posts.author`, `posts.author.profile`, etc.
-   * - `allowGraph("posts.author")` allows `posts.author` and `posts.author.profile`,
-   *   but NOT bare `posts` or `posts.comments`.
-   *
-   * Multiple arguments are merged: `allowGraph("posts", "profile")`
-   */
-  allowGraph(...expressions: string[]): QueryBuilder;
-  updateMany(data: Record<string, unknown>): Promise<number>;
-  deleteMany(): Promise<number>;
-  withTrashed(): QueryBuilder;
-  onlyTrashed(): QueryBuilder;
-  whereIn(column: string, values: unknown[]): QueryBuilder;
-  whereInPivot(column: string, values: unknown[]): QueryBuilder;
-  has(relationName: string): QueryBuilder;
-  whereHas(relationName: string, callback?: (qb: QueryBuilder) => void): QueryBuilder;
-  whereDoesntHave(relationName: string, callback?: (qb: QueryBuilder) => void): QueryBuilder;
-  where(column: string, operator: unknown, value?: unknown): QueryBuilder;
-  whereRef(col1: string, operator: string, col2: string): QueryBuilder;
-  orWhere(column: string, operator: unknown, value?: unknown): QueryBuilder;
-  orderBy(column: string, direction?: "asc" | "desc"): QueryBuilder;
-  limit(n: number): QueryBuilder;
-  offset(n: number): QueryBuilder;
-  select(...columns: string[]): QueryBuilder;
-  selectAll(table?: string): QueryBuilder;
-  innerJoin(table: string, lhs: string, rhs: string): QueryBuilder;
-  leftJoin(table: string, lhs: string, rhs: string): QueryBuilder;
-  groupBy(...columns: string[]): QueryBuilder;
-  having(column: string, operator: string, value: unknown): QueryBuilder;
-  withoutGlobalScope(name: string): QueryBuilder;
-  all(): QueryBuilder;
-  /** @internal Access underlying Kysely builder for raw SQL operations */
-  _getKyselyQb(): any;
-  /** @internal Replace the underlying Kysely builder */
-  _replaceKyselyQb(newQb: any): void;
-  when(condition: unknown, callback: (q: QueryBuilder) => QueryBuilder): QueryBuilder;
-  unless(condition: unknown, callback: (q: QueryBuilder) => QueryBuilder): QueryBuilder;
-}
-//#endregion
-//#region src/query/builder.d.ts
-declare function createQueryBuilder(def: ModelDefinition, peta?: {
-  kysely: Database;
-}): QueryBuilder;
-//#endregion
-//#region src/relations/related-query.d.ts
-interface RelationQuery extends QueryBuilder {
-  /** Attach related model(s) for many-to-many relations. */
-  attach(ids: number | number[] | string | string[], pivotData?: Record<string, unknown>): Promise<void>;
-  /** Detach related model(s) for many-to-many relations. */
-  detach(ids?: number | number[] | string | string[]): Promise<void>;
-  /** Sync related models: attaches new IDs, detaches missing ones. */
-  sync(ids: (number | string)[] | Record<number | string, Record<string, unknown>>): Promise<void>;
-  /** Sync without detaching existing IDs. */
-  syncWithoutDetaching(ids: (number | string)[]): Promise<void>;
-  /** Update pivot data for a specific related model. */
-  updateExistingPivot(id: number | string, data: Record<string, unknown>): Promise<void>;
-}
-//#endregion
-//#region src/plugins/index.d.ts
-/**
- * A plugin is a function that receives a model definition and can
- * modify it by adding hooks, scopes, columns, or methods.
- *
- * ```ts
- * const myPlugin = (options?: MyOptions): Plugin =>
- *   (def) => {
- *     def.addGlobalScope?.('active', (q) => q.where('active', true))
- *     return def
- *   }
- * ```
- */
-type Plugin = (def: ModelDefinition) => undefined | ModelDefinition;
-//#endregion
-//#region src/columns/schema.d.ts
-interface Constraint {
-  type: string;
-  args: unknown[];
-}
-interface SchemaConfig {
-  compile(dataType: string, args: unknown[], constraints: Constraint[]): unknown;
-  parse<T>(schema: unknown, value: unknown): T;
-  assert<T>(schema: unknown, value: unknown): T;
-}
-//#endregion
-//#region src/columns/column.d.ts
-interface Column<out T = unknown> {
-  readonly arkType: unknown;
-  readonly dataType: string;
-  readonly args: readonly unknown[];
-  readonly constraints: readonly Constraint[];
-  readonly isNullable: boolean;
-  readonly isPrimaryKey: boolean;
-  readonly isUnique: boolean;
-  readonly defaultValue: unknown;
-  hasConstraint(type: string): boolean;
-  parse(value: unknown): T;
-  assert(value: unknown): T;
-  primaryKey(): Column<T>;
-  nullable(): Column<T | null>;
-  default<V>(value: V): Column<T>;
-  unique(): Column<T>;
-  index(): Column<T>;
-  min(n: number): Column<T>;
-  max(n: number): Column<T>;
-  email(): Column<T>;
-  url(): Column<T>;
-  pattern(regex: RegExp | string): Column<T>;
-  references(table: () => unknown, columns: string[]): Column<T>;
-}
-declare function createColumn<T>(schema: SchemaConfig, dataType: string, args?: unknown[], constraints?: Constraint[]): Column<T>;
-type ColumnShape = Record<string, Column>;
-type ColumnValue<C> = C extends Column<infer T> ? T : never;
-//#endregion
-//#region src/types.d.ts
-type ModelId = number & {
-  readonly __brand: "ModelId";
-};
-interface ModelLike {
-  get<T = unknown>(key: string): T;
-  set(key: string, value: unknown): void;
-}
-interface ORMLike {
-  readonly kysely: Database;
-  register(model: ModelDefinition$1<any>): void;
-  registerAll(...models: (ModelDefinition$1<any> | ModelDefinition$1<any>[])[]): void;
-  destroy(): Promise<void>;
-  transaction<T>(fn: (trx: import("kysely").Kysely<Record<string, never>>) => Promise<T>): Promise<T>;
-  readonly models: ReadonlyMap<string, ModelDefinition$1<any>>;
-  getModel<T extends ColumnShape = ColumnShape>(name: string): ModelDefinition$1<T> | undefined;
-}
-interface ModelDefinition$1<TColumns extends ColumnShape = ColumnShape> {
-  readonly table: string;
-  readonly columns: TColumns;
-  readonly relations: Record<string, Relation>;
-  readonly name: string;
-  _orm: ORMLike | null;
-  query(): QueryBuilder;
-  find(id: number | string): Promise<ModelInstance | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance>;
-  first(): Promise<ModelInstance | undefined>;
-  create(data: Record<string, unknown>): Promise<ModelInstance>;
-  insert(data: Record<string, unknown>): Promise<ModelInstance>;
-  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance[]>;
-  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance>;
-  delete(id: number | string): Promise<void>;
-  hydrate(row: Record<string, unknown>): ModelInstance;
-  on(event: string, callback: (model: ModelInstance) => void | Promise<void>): () => void;
-  getHooks(): HookManager;
-  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
-  removeGlobalScope(name: string): void;
-  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
-  _init(orm: ORMLike): void;
-}
-//#endregion
-//#region src/hooks/index.d.ts
-type LifecycleEvent = "beforeCreate" | "afterCreate" | "beforeUpdate" | "afterUpdate" | "beforeSave" | "afterSave" | "beforeDelete" | "afterDelete" | "beforeRestore" | "afterRestore" | "beforeForceDelete" | "afterForceDelete";
-type HookCallback = (model: ModelLike) => void | Promise<void>;
-interface HookManager {
-  on(event: LifecycleEvent, callback: HookCallback): () => void;
-  off(event: LifecycleEvent, callback: HookCallback): void;
-  trigger(event: LifecycleEvent, model: ModelLike): Promise<void>;
-  clone(): HookManager;
-}
-declare function createHookManager(): HookManager;
-//#endregion
-//#region src/hooks/static.d.ts
-interface StaticHookArgs {
-  /** Transform the mutating query into a SELECT to preview affected rows */
-  asFindQuery(): QueryBuilder;
-  /** Cancel the mutation and return a custom result */
-  cancelQuery(result: unknown): void;
-  /** The column data being inserted/updated (for create/update hooks) */
-  inputItems?: Record<string, unknown>[];
-}
-type StaticHookCallback = (args: StaticHookArgs) => void | Promise<void>;
-//#endregion
-//#region src/model/computed.d.ts
-interface ComputedColumn<T = unknown> {
-  readonly type: "sql" | "runtime" | "batch";
-  readonly dependencies: string[];
-  /** Compute a value for a single record (runtime) */
-  compute?: (record: ModelInstance) => T;
-  /** Compute values for a batch of records (batch async) */
-  batchCompute?: (records: ModelInstance[]) => Promise<T[]>;
-  /** Raw SQL expression to inline in SELECT */
-  sql?: string;
-}
-//#endregion
-//#region src/model/attribute.d.ts
-/**
- * Defines an accessor (`get`) and/or mutator (`set`) for a model attribute.
- *
- * ### Accessor (get)
- * Transforms the attribute value when read via `model.get()` or `model.$toJSON()`.
- * Receives the casted value and the model instance.
- *
- * ### Mutator (set)
- * Transforms the attribute value when written via `model.set()`, `model.fill()`,
- * or during model creation (`Model.insert()` / `Model.create()`).
- * Receives the raw input value and the model instance, returns the value to store.
- * Applied **before** type casting.
- *
- * ### Usage
- * ```ts
- * defineModel('users', {
- *   columns: { id, name, password, ... },
- *   attributes: {
- *     password: Attribute.make({
- *       set: (value) => Bun.password.hashSync(value, { algorithm: 'bcrypt' }),
- *       get: () => '***',
- *     }),
- *     fullName: Attribute.make({
- *       get: (_, instance) => `${instance.get('firstName')} ${instance.get('lastName')}`,
- *     }),
- *   },
- * })
- * ```
- */
-declare class Attribute<T = any> {
-  readonly get?: ((value: T, instance: ModelInstance) => any) | undefined;
-  readonly set?: ((value: any, instance: ModelInstance) => T) | undefined;
-  private constructor();
-  static make<T = any>(config: {
-    /** Transform the attribute value when read. Receives (castedValue, instance). */get?: (value: T, instance: ModelInstance) => any; /** Transform the attribute value when written. Receives (rawValue, instance), returns value to store. */
-    set?: (value: any, instance: ModelInstance) => T;
-  }): Attribute<T>;
-}
-//#endregion
-//#region src/model/types.d.ts
-interface ModelInstance {
-  readonly exists: boolean;
-  readonly attributes: Record<string, unknown>;
-  readonly dirtyAttributes: Record<string, unknown>;
-  isDirty(key?: string): boolean;
-  get<T = unknown>(key: string): T;
-  set(key: string, value: unknown): void;
-  fill(data: Record<string, unknown>): void;
-  reset(): void;
-  $getRelation<T = unknown>(name: string): T;
-  $setRelation(name: string, value: unknown): void;
-  $hasRelation(name: string): boolean;
-  $relationData(): Record<string, unknown>;
-  $load(...relations: string[]): Promise<void>;
-  $related(name: string): RelationQuery;
-  $save(): Promise<this>;
-  $delete(): Promise<void>;
-  $forceDelete(): Promise<void>;
-  $restore(): Promise<void>;
-  $trashed(): boolean;
-  $reload(): Promise<void>;
-  $toJSON(): Record<string, unknown>;
-  toJSON(): Record<string, unknown>;
-}
-interface ModelDefinition<TColumns extends ColumnShape = ColumnShape> {
-  readonly table: string;
-  readonly columns: TColumns;
-  readonly relations: Record<string, Relation>;
-  readonly name: string;
-  _orm: ORMLike | null;
-  query(): QueryBuilder;
-  find(id: number | string): Promise<ModelInstance | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance>;
-  first(): Promise<ModelInstance | undefined>;
-  create(data: Record<string, unknown>): Promise<ModelInstance>;
-  insert(data: Record<string, unknown>): Promise<ModelInstance>;
-  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance[]>;
-  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance>;
-  delete(id: number | string): Promise<void>;
-  insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
-  upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
-  hydrate(row: Record<string, unknown>): ModelInstance;
-  use(plugin: Plugin): ModelDefinition;
-  makeHelper<A extends any[], R>(fn: (qb: QueryBuilder, ...args: A) => R): (...args: A) => R;
-  on(event: string, callback: (model: ModelInstance) => void | Promise<void>): () => void;
-  getHooks(): HookManager;
-  beforeDelete(callback: StaticHookCallback): () => void;
-  afterDelete(callback: StaticHookCallback): () => void;
-  beforeUpdate(callback: StaticHookCallback): () => void;
-  afterUpdate(callback: StaticHookCallback): () => void;
-  beforeCreate(callback: StaticHookCallback): () => void;
-  afterCreate(callback: StaticHookCallback): () => void;
-  beforeFind(callback: StaticHookCallback): () => void;
-  afterFind(callback: StaticHookCallback): () => void;
-  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
-  removeGlobalScope(name: string): void;
-  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
-  registerTimestamps?(createdAtCol?: string, updatedAtCol?: string): void;
-  registerSoftDeletes?(deletedAtCol?: string): void;
-  discover?(): Promise<never>;
-  _init(orm: ORMLike): void;
-}
-interface ModelConfig<TColumns extends ColumnShape = ColumnShape> {
-  columns: TColumns;
-  relations?: Record<string, Relation>;
-  casts?: Record<string, string>;
-  /** Per-attribute accessors (`get`) and/or mutators (`set`). See {@link Attribute.make}. */
-  attributes?: Record<string, Attribute<any>>;
-  hidden?: string[];
-  visible?: string[];
-  appends?: string[];
-  computed?: Record<string, ComputedColumn>;
-}
-//#endregion
-//#region src/collection/index.d.ts
-interface Collection {
-  readonly length: number;
-  [Symbol.iterator](): Iterator<ModelInstance>;
-  at(index: number): ModelInstance | undefined;
-  first(): ModelInstance | undefined;
-  last(): ModelInstance | undefined;
-  all(): ModelInstance[];
-  findBy(id: number | string): ModelInstance | undefined;
-  find(callback: (item: ModelInstance, index: number) => boolean): ModelInstance | undefined;
-  some(callback: (item: ModelInstance, index: number) => boolean): boolean;
-  includes(item: ModelInstance): boolean;
-  isEmpty(): boolean;
-  isNotEmpty(): boolean;
-  get(key: string): unknown[];
-  pluck(key: string): unknown[];
-  groupBy(key: string): Record<string, ModelInstance[]>;
-  keyBy(key: string): Record<string, ModelInstance>;
-  map<T>(fn: (item: ModelInstance, index: number) => T): T[];
-  filter(fn: (item: ModelInstance, index: number) => boolean): Collection;
-  reduce<T>(fn: (acc: T, item: ModelInstance, index: number) => T, initial: T): T;
-  forEach(fn: (item: ModelInstance, index: number) => void): void;
-  each(fn: (item: ModelInstance, index: number) => void): Collection;
-  unique(key?: string): Collection;
-  sortBy(key: string, direction?: "asc" | "desc"): Collection;
-  shuffle(): Collection;
-  take(n: number): Collection;
-  skip(n: number): Collection;
-  chunk(size: number): Collection[];
-  sum(key: string): number;
-  avg(key: string): number;
-  min(key: string): number;
-  max(key: string): number;
-  diff(other: Collection): Collection;
-  intersect(other: Collection): Collection;
-  concat(other: Collection): Collection;
-  push(...items: ModelInstance[]): void;
-  load(...relations: string[]): Promise<Collection>;
-  toJSON(): Record<string, unknown>[];
-}
-declare function createCollection(items?: ModelInstance[]): Collection;
-//#endregion
-//#region src/model/define.d.ts
-declare function defineModel<TColumns extends ColumnShape>(table: string, config: ModelConfig<TColumns>): ModelDefinition<TColumns>;
-//#endregion
-export { PaginatorJson as A, InsertGraphOptions as C, RelationType as D, RelationOptions as E, Database as M, PaginatedResult as O, QueryBuilder as S, Relation as T, createColumn as _, ModelDefinition as a, Plugin as b, HookCallback as c, createHookManager as d, ModelId as f, ColumnValue as g, ColumnShape as h, ModelConfig as i, createPaginator as j, Paginator as k, HookManager as l, Column as m, Collection as n, ModelInstance as o, ORMLike as p, createCollection as r, Attribute as s, defineModel as t, LifecycleEvent as u, Constraint as v, UpsertGraphOptions as w, createQueryBuilder as x, SchemaConfig as y };

package/dist/migrations/cli.d.mts

@@ -1,4 +0,0 @@
-//#region src/migrations/cli.d.ts
-declare function run(): Promise<void>;
-//#endregion
-export { run };

package/dist/migrations/cli.mjs

@@ -1,74 +0,0 @@
-import { a as loadMigrationFiles, i as loadConfig, n as createMigrationGenerator, t as createMigrationRunner } from "../runner-DQ7uT6LC.mjs";
-import { resolve } from "node:path";
-import { mkdirSync, writeFileSync } from "node:fs";
-import cac from "cac";
-import ora from "ora";
-//#region src/migrations/cli.ts
-async function run() {
-	const cli = cac("peta");
-	cli.command("migrate:init", "Create migrations directory and tracking table").action(async () => {
-		const config = await loadConfig();
-		const spinner = ora("Setting up migrations...").start();
-		mkdirSync(config.migrationsDir, { recursive: true });
-		await createMigrationRunner(config.getKysely()).ensureTable();
-		spinner.succeed(`Migrations directory created at ${config.migrationsDir}`);
-	});
-	cli.command("migrate:generate [name]", "Generate initial migration from models").action(async (name) => {
-		const config = await loadConfig();
-		const spinner = ora("Generating migration...").start();
-		const code = createMigrationGenerator().generateInitialMigration(/* @__PURE__ */ new Map(), { name: name ?? "Initial" });
-		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
-		const safeName = (name ?? "initial").replace(/[^a-zA-Z0-9_]/g, "_");
-		const filename = resolve(config.migrationsDir, `${timestamp}_${safeName}.ts`);
-		mkdirSync(config.migrationsDir, { recursive: true });
-		writeFileSync(filename, code);
-		spinner.succeed(`Created ${filename}`);
-	});
-	cli.command("migrate:up", "Apply pending migrations").action(async () => {
-		const config = await loadConfig();
-		const migrations = await loadMigrationFiles(config.migrationsDir);
-		if (migrations.length === 0) {
-			console.log("No migration files found.");
-			return;
-		}
-		const runner = createMigrationRunner(config.getKysely());
-		const status = await runner.status(migrations);
-		if (status.pending.length === 0) {
-			console.log("All migrations have been applied.");
-			return;
-		}
-		const spinner = ora(`Running ${status.pending.length} migration(s)...`).start();
-		await runner.up(migrations);
-		spinner.succeed(`Applied ${(await runner.getCompleted()).length} migration(s)`);
-	});
-	cli.command("migrate:down", "Rollback last batch").action(async () => {
-		const config = await loadConfig();
-		const migrations = await loadMigrationFiles(config.migrationsDir);
-		if (migrations.length === 0) {
-			console.log("No migration files found.");
-			return;
-		}
-		const runner = createMigrationRunner(config.getKysely());
-		if ((await runner.getCompleted()).length === 0) {
-			console.log("Nothing to rollback.");
-			return;
-		}
-		const spinner = ora("Rolling back...").start();
-		await runner.down(migrations);
-		spinner.succeed("Rolled back");
-	});
-	cli.command("migrate:status", "Show migration status").action(async () => {
-		const config = await loadConfig();
-		const migrations = await loadMigrationFiles(config.migrationsDir);
-		const { completed, pending } = await createMigrationRunner(config.getKysely()).status(migrations);
-		console.log(`\n  Completed: ${completed.length}`);
-		for (const m of completed) console.log(`    ✓ ${m.name}`);
-		console.log(`\n  Pending: ${pending.length}`);
-		for (const m of pending) console.log(`    · ${m.name}`);
-		console.log();
-	});
-	cli.help();
-	cli.parse();
-}
-//#endregion
-export { run };

package/dist/migrations/index.d.mts

@@ -1,53 +0,0 @@
-import { a as ModelDefinition } from "../index-BdJnSMYi.mjs";
-import { Kysely } from "kysely";
-
-//#region src/migrations/types.d.ts
-interface MigrationFile {
-  name: string;
-  up: (db: Kysely<unknown>) => Promise<void>;
-  down: (db: Kysely<unknown>) => Promise<void>;
-}
-interface MigrationRecord {
-  name: string;
-  appliedAt: string;
-}
-interface MigrationStatus {
-  completed: MigrationRecord[];
-  pending: MigrationFile[];
-}
-interface PetaMigrateConfig {
-  migrationsDir: string;
-  models: string[] | string;
-  getKysely: () => Kysely<unknown>;
-}
-interface ResolvedConfig {
-  migrationsDir: string;
-  models: string[] | string;
-  getKysely: () => Kysely<unknown>;
-}
-//#endregion
-//#region src/migrations/config.d.ts
-declare function defineConfig(config: PetaMigrateConfig): PetaMigrateConfig;
-declare function loadConfig(): Promise<ResolvedConfig>;
-declare function loadMigrationFiles(dir: string): Promise<MigrationFile[]>;
-//#endregion
-//#region src/migrations/generator.d.ts
-interface GeneratorOptions {
-  name?: string;
-}
-interface MigrationGenerator {
-  generateInitialMigration(models: Map<string, ModelDefinition>, options?: GeneratorOptions): string;
-}
-declare function createMigrationGenerator(): MigrationGenerator;
-//#endregion
-//#region src/migrations/runner.d.ts
-interface MigrationRunner {
-  ensureTable(): Promise<void>;
-  getCompleted(): Promise<MigrationRecord[]>;
-  up(migrations: MigrationFile[]): Promise<void>;
-  down(migrations: MigrationFile[]): Promise<void>;
-  status(migrations: MigrationFile[]): Promise<MigrationStatus>;
-}
-declare function createMigrationRunner(db: Kysely<Record<string, never>>, table?: string): MigrationRunner;
-//#endregion
-export { type GeneratorOptions, type MigrationFile, type MigrationGenerator, type MigrationRecord, type MigrationRunner, type MigrationStatus, type PetaMigrateConfig, type ResolvedConfig, createMigrationGenerator, createMigrationRunner, defineConfig, loadConfig, loadMigrationFiles };

package/dist/migrations/index.mjs

@@ -1,2 +0,0 @@
-import { a as loadMigrationFiles, i as loadConfig, n as createMigrationGenerator, r as defineConfig, t as createMigrationRunner } from "../runner-DQ7uT6LC.mjs";
-export { createMigrationGenerator, createMigrationRunner, defineConfig, loadConfig, loadMigrationFiles };

package/dist/runner-DQ7uT6LC.mjs

@@ -1,180 +0,0 @@
-import { sql } from "kysely";
-import { resolve } from "node:path";
-//#region src/migrations/config.ts
-function defineConfig(config) {
-	return config;
-}
-async function loadConfig() {
-	const candidates = [
-		"peta.config.ts",
-		"peta.config.js",
-		"peta.config.mjs"
-	];
-	let mod = null;
-	for (const file of candidates) try {
-		mod = await import(resolve(process.cwd(), file));
-		break;
-	} catch {}
-	if (!mod) throw new Error("No peta.config.ts found. Create one in your project root.");
-	const config = mod.default ?? mod;
-	return {
-		migrationsDir: config.migrationsDir,
-		models: config.models,
-		getKysely: config.getKysely
-	};
-}
-async function loadMigrationFiles(dir) {
-	const { readdirSync } = await import("node:fs");
-	const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
-	const migrations = [];
-	for (const file of files) {
-		const mod = await import(resolve(dir, file));
-		if (mod.up) migrations.push({
-			name: file.replace(/\.(ts|js)$/, ""),
-			up: mod.up,
-			down: mod.down ?? (async () => {})
-		});
-	}
-	return migrations;
-}
-//#endregion
-//#region src/migrations/generator.ts
-function createMigrationGenerator() {
-	function generateInitialMigration(models, options = {}) {
-		options.name;
-		const parts = [];
-		const indexParts = [];
-		const warnings = [];
-		const registeredTables = new Set([...models.values()].map((m) => m.table).filter(Boolean));
-		for (const [, modelDef] of models) {
-			const table = modelDef.table;
-			if (!table) continue;
-			parts.push(generateCreateTable(table, modelDef.columns));
-			for (const [colName, col] of Object.entries(modelDef.columns)) if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) indexParts.push(generateCreateIndex(table, colName));
-			for (const [, rel] of Object.entries(modelDef.relations ?? {})) if (rel.type === "manyToMany") {
-				const through = rel.throughTable;
-				if (through && !registeredTables.has(through)) warnings.push(`// ⚠ Detected ManyToMany "${modelDef.name}" references table "${through}" but no model is registered for it.\n//   Add a model to include the pivot table.`);
-			}
-		}
-		const upBody = [...parts, ...indexParts].join("\n\n");
-		const downTables = [...models.values()].filter((m) => m.table).map((m) => `  await db.schema.dropTable("${m.table}").ifExists().execute()`).join("\n");
-		return `import type { Kysely } from "kysely"\nimport { sql } from "kysely"\n\nexport async function up(db: Kysely<any>): Promise<void> {\n${warnings.length > 0 ? `  // Warnings:\n${warnings.join("\n")}\n\n` : ""}${upBody}\n}\n\nexport async function down(db: Kysely<any>): Promise<void> {\n${downTables}\n}\n`;
-	}
-	return { generateInitialMigration };
-}
-function generateCreateTable(table, columns) {
-	const lines = [`  await db.schema.createTable("${table}").ifNotExists()`];
-	for (const [name, col] of Object.entries(columns)) lines.push(`    .addColumn("${name}", "${mapType(col)}"${columnCallback(col)})`);
-	lines.push("    .execute()");
-	return lines.join("\n");
-}
-function generateCreateIndex(table, column) {
-	return [
-		`  await db.schema.createIndex("${table}_${column}_index")`,
-		`    .on("${table}")`,
-		`    .column("${column}")`,
-		"    .execute()"
-	].join("\n");
-}
-function columnCallback(col) {
-	const calls = [];
-	if (col.isPrimaryKey) {
-		if (col.dataType === "integer") calls.push("autoIncrement()");
-		calls.push("primaryKey()");
-	}
-	if (!col.isNullable && !col.isPrimaryKey) calls.push("notNull()");
-	const dv = col.defaultValue;
-	if (dv !== void 0 && typeof dv !== "function") calls.push(`defaultTo(${JSON.stringify(dv)})`);
-	if (col.isUnique && !col.isPrimaryKey) calls.push("unique()");
-	const refConstraint = col.constraints.find((c) => c.type === "references");
-	if (refConstraint?.args[0]) {
-		const targetTable = (typeof refConstraint.args[0] === "function" ? refConstraint.args[0]() : refConstraint.args[0])?.table;
-		const targetColumns = refConstraint.args[1];
-		if (typeof targetTable === "string" && targetTable && targetColumns?.length) calls.push(`references("${targetTable}.${targetColumns[0]}")`);
-	}
-	return calls.length === 0 ? "" : `, (c) => c.${calls.join(".")}`;
-}
-function mapType(col) {
-	switch (col.dataType) {
-		case "integer":
-		case "smallint":
-		case "bigint":
-		case "text":
-		case "boolean":
-		case "timestamp":
-		case "date":
-		case "float":
-		case "double":
-		case "uuid": return col.dataType;
-		case "string": {
-			const max = col.args[0];
-			return max != null ? `varchar(${max})` : "varchar";
-		}
-		case "json":
-		case "jsonb": return "json";
-		case "decimal": {
-			const p = col.args[0];
-			const s = col.args[1];
-			return p != null ? `decimal(${p}, ${s ?? 0})` : "decimal";
-		}
-		case "enum": return "text";
-		default: return col.dataType;
-	}
-}
-//#endregion
-//#region src/migrations/runner.ts
-function createMigrationRunner(db, table = "_peta_migrations") {
-	async function ensureTable() {
-		await db.schema.createTable(table).ifNotExists().addColumn("name", "varchar", (c) => c.notNull().primaryKey()).addColumn("applied_at", "timestamp", (c) => c.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
-	}
-	async function getCompleted() {
-		try {
-			return (await db.selectFrom(table).select(["name", "applied_at"]).orderBy("name", "asc").execute()).map((r) => ({
-				name: String(r.name),
-				appliedAt: String(r.applied_at)
-			}));
-		} catch {
-			return [];
-		}
-	}
-	async function up(migrations) {
-		await ensureTable();
-		const completed = await getCompleted();
-		const completedNames = new Set(completed.map((r) => r.name));
-		for (const m of migrations.filter((m) => !completedNames.has(m.name)).sort(byName)) {
-			await m.up(db);
-			await db.insertInto(table).values({
-				name: m.name,
-				applied_at: (/* @__PURE__ */ new Date()).toISOString()
-			}).execute();
-		}
-	}
-	async function down(migrations) {
-		const completed = await getCompleted();
-		if (completed.length === 0 || migrations.length === 0) return;
-		for (const m of migrations.filter((m) => completed.some((r) => r.name === m.name)).sort(byName).reverse()) {
-			await m.down(db);
-			await db.deleteFrom(table).where("name", "=", m.name).execute();
-		}
-	}
-	async function status(migrations) {
-		const completed = await getCompleted();
-		const completedNames = new Set(completed.map((r) => r.name));
-		return {
-			completed,
-			pending: migrations.filter((m) => !completedNames.has(m.name)).sort(byName)
-		};
-	}
-	return {
-		ensureTable,
-		getCompleted,
-		up,
-		down,
-		status
-	};
-}
-function byName(a, b) {
-	return a.name.localeCompare(b.name);
-}
-//#endregion
-export { loadMigrationFiles as a, loadConfig as i, createMigrationGenerator as n, defineConfig as r, createMigrationRunner as t };