peta-orm 0.2.6 → 0.3.0

package/dist/index-BdJnSMYi.d.mts

@@ -0,0 +1,480 @@
+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 };