peta-orm 0.3.0 → 0.4.1

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/dist/index.mjs

@@ -1,10 +1,10 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as createCollection } from "./collection-Dv3sQPMx.mjs";
+import { n as createCollection } from "./collection-PFmrQHyM.mjs";
 import { a as ModelNotRegisteredError, c as ValidationError, i as ModelNotFoundError, n as normalizeError, o as RelationNotAllowedError, r as DatabaseError, s as RelationNotFoundError } from "./errors-sfFJolfu.mjs";
 import { a as registerSoftDeletesFor, n as getSoftDeleteConfig, o as registerTimestampsFor, r as hasSoftDelete, s as createHookManager, t as getHooksFor } from "./hooks-BD0xy7uw.mjs";
-import { a as castValue, r as initRuntime, t as createInstance } from "./factory-rIbPGjRg.mjs";
+import { a as castValue, r as initRuntime, t as createInstance } from "./factory-BBvIMQuc.mjs";
 import { a as getRawRelations, d as setExists, o as getState } from "./state-LtlHp6XV.mjs";
-import { a as setConfig$1, n as reloadModel, r as saveModel, t as getConfig$1 } from "./save-B8rudcT5.mjs";
+import { a as setConfig$1, n as reloadModel, r as saveModel, t as getConfig$1 } from "./save-D5UKXvqC.mjs";
 import { type } from "arktype";
 import { Kysely, sql } from "kysely";
 import { ulid as ulid$1 } from "ulid";
@@ -948,7 +948,7 @@ function createQueryBuilder(def, peta) {
 		execute: runExecute,
 		async collect() {
 			const items = await runExecute();
-			const { createCollection } = await import("./collection-Dv3sQPMx.mjs").then((n) => n.t);
+			const { createCollection } = await import("./collection-PFmrQHyM.mjs").then((n) => n.t);
 			return createCollection(items);
 		},
 		async executeTakeFirst() {
@@ -1396,16 +1396,16 @@ function defineModel(table, config) {
 			return this.query().first();
 		},
 		async create(data) {
-			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).insertModel(def, data);
+			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).insertModel(def, data);
 		},
 		async insert(data) {
-			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).insertModel(def, data);
+			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).insertModel(def, data);
 		},
 		async insertMany(dataArray) {
-			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).insertManyModel(def, dataArray);
+			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).insertManyModel(def, dataArray);
 		},
 		async update(id, data) {
-			return (await import("./save-B8rudcT5.mjs").then((n) => n.i)).updateModel(def, id, data);
+			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).updateModel(def, id, data);
 		},
 		async insertGraph(data, options) {
 			return (await Promise.resolve().then(() => graph_exports)).insertGraph(def, data, options);
@@ -2157,7 +2157,10 @@ function hasMany(relatedThunk, options = {}) {
 function hasOne(relatedThunk, options = {}) {
 	const base = hasMany(relatedThunk, options);
 	const result = {};
-	for (const key of Object.keys(base)) Object.defineProperty(result, key, Object.getOwnPropertyDescriptor(base, key));
+	for (const key of Object.keys(base)) {
+		const desc = Object.getOwnPropertyDescriptor(base, key);
+		Object.defineProperty(result, key, desc);
+	}
 	result.match = function match(models, results, relationName) {
 		const grouped = groupByArray$1(results, base.foreignKey);
 		for (const model of models) {

package/dist/{save-B8rudcT5.mjs → save-D5UKXvqC.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { n as normalizeError, r as DatabaseError } from "./errors-sfFJolfu.mjs";
 import { t as getHooksFor } from "./hooks-BD0xy7uw.mjs";
-import { i as applyCastsToData, o as prepareForDb, t as createInstance } from "./factory-rIbPGjRg.mjs";
+import { i as applyCastsToData, o as prepareForDb, t as createInstance } from "./factory-BBvIMQuc.mjs";
 import { d as setExists, f as syncOriginal, i as getExists, o as getState } from "./state-LtlHp6XV.mjs";
 //#region src/model/save.ts
 var save_exports = /* @__PURE__ */ __exportAll({

package/package.json

@@ -2,7 +2,7 @@
   "name": "peta-orm",
   "type": "module",
   "private": false,
-  "version": "0.3.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"
@@ -38,7 +30,7 @@
     "ulid": "^3.0.2"
   },
   "peerDependencies": {
-    "kysely": "^0.28.17",
+    "kysely": "^0.29.2",
     "typescript": "^6.0.0"
   },
   "devDependencies": {
@@ -46,8 +38,9 @@
     "@types/bun": "^1.3.14",
     "elysia": "^1.4.28",
     "hono": "^4.12.25",
-    "kysely": "^0.28.17",
-    "kysely-bun-sqlite": "^0.4.0",
+    "kysely": "^0.29.2",
+    "@libsql/kysely-libsql": "^0.4.1",
+    "@libsql/client": "^0.8.0",
     "mysql2": "^3.22.5",
     "pg": "^8.21.0",
     "tsdown": "^0.22.2",

package/bin/peta

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