peta-orm 0.2.6 → 0.3.0

package/dist/index.d.mts

@@ -0,0 +1,215 @@
+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";
+
+//#region src/columns/arktype.d.ts
+declare function createArkTypeSchemaConfig(): SchemaConfig;
+//#endregion
+//#region src/columns/types.d.ts
+interface ColumnTypes {
+  integer: () => Column<number>;
+  smallint: () => Column<number>;
+  bigint: () => Column<number>;
+  string: (maxLength?: number) => Column<string>;
+  text: () => Column<string>;
+  boolean: () => Column<boolean>;
+  timestamp: () => Column<string>;
+  date: () => Column<string>;
+  json: <T = unknown>() => Column<T>;
+  jsonb: <T = unknown>() => Column<T>;
+  float: () => Column<number>;
+  double: () => Column<number>;
+  decimal: (precision?: number, scale?: number) => Column<number>;
+  uuid: () => Column<string>;
+  enum: <T extends string>(...values: T[]) => Column<T>;
+  timestamps: () => {
+    createdAt: Column<string>;
+    updatedAt: Column<string>;
+  };
+}
+declare function t(config: {
+  schema: SchemaConfig;
+}): ColumnTypes;
+//#endregion
+//#region src/errors/classes.d.ts
+type DatabaseErrorCode = "UNIQUE_CONSTRAINT" | "FOREIGN_KEY_CONSTRAINT" | "NOT_NULL_CONSTRAINT" | "CHECK_CONSTRAINT" | "MISSING_ID" | "RELATION_NOT_FOUND" | "MODEL_NOT_REGISTERED" | "UNKNOWN";
+declare class ValidationError extends Error {
+  name: "ValidationError";
+}
+declare class ModelNotFoundError extends Error {
+  name: "ModelNotFoundError";
+  constructor(model: string, id: ModelIdValue);
+}
+type ModelIdValue = number | string | bigint;
+declare class RelationNotFoundError extends Error {
+  name: "RelationNotFoundError";
+  constructor(model: string, relation: string);
+}
+declare class RelationNotAllowedError extends Error {
+  name: "RelationNotAllowedError";
+  constructor(model: string, relation: string);
+}
+declare class ModelNotRegisteredError extends Error {
+  name: "ModelNotRegisteredError";
+  constructor(model: string);
+}
+declare class DatabaseError extends Error {
+  name: "DatabaseError";
+  code: DatabaseErrorCode;
+  table?: string;
+  detail?: string;
+  constructor(message: string, code: DatabaseErrorCode, table?: string, detail?: string);
+}
+//#endregion
+//#region src/errors/normalizer.d.ts
+declare function normalizeError(e: unknown, table?: string): DatabaseError;
+//#endregion
+//#region src/orm/index.d.ts
+interface ORMConfig {
+  dialect: Dialect;
+  models?: Record<string, ModelDefinition>;
+}
+/**
+ * Create an ORM instance — the central registry that wires Kysely to model definitions.
+ * Replaces createPeta() from v0.x.
+ */
+declare function createORM(config: ORMConfig): ORMLike & {
+  kysely: Database;
+};
+//#endregion
+//#region src/plugins/soft-deletes.d.ts
+/**
+ * Plugin that enables soft-delete behavior on a model.
+ * Sets `deletedAt` on delete, automatically filters out deleted records.
+ *
+ * ```ts
+ * const User = defineModel('users', {
+ *   columns: { deletedAt: t.timestamp().nullable() }
+ * }).use(softDeletes())
+ * ```
+ */
+declare function softDeletes(opts?: {
+  column?: string;
+}): Plugin;
+//#endregion
+//#region src/plugins/timestamps.d.ts
+/**
+ * Plugin that automatically sets `createdAt` and `updatedAt` timestamps.
+ *
+ * ```ts
+ * const User = defineModel('users', { columns: { ...t.timestamps() } })
+ *   .use(timestamps())
+ * ```
+ */
+declare function timestamps(opts?: {
+  createdAt?: string;
+  updatedAt?: string;
+}): Plugin;
+//#endregion
+//#region src/plugins/ulid.d.ts
+/**
+ * Plugin that auto-generates ULID primary keys on `beforeCreate`.
+ *
+ * Requires the model's `id` column to be `t.string(26).primaryKey()`.
+ *
+ * @example
+ * ```ts
+ * const User = defineModel("users", {
+ *   columns: { id: t.string(26).primaryKey() }
+ * }).use(ulid())
+ * ```
+ */
+declare function ulid(): Plugin;
+//#endregion
+//#region src/relations/has-many.d.ts
+declare function hasMany(relatedThunk: () => ModelDefinition, options?: RelationOptions): Relation;
+declare function hasOne(relatedThunk: () => ModelDefinition, options?: RelationOptions): Relation;
+declare function belongsTo(relatedThunk: () => ModelDefinition, options?: RelationOptions): Relation;
+//#endregion
+//#region src/relations/many-to-many.d.ts
+declare function manyToMany(relatedThunk: () => ModelDefinition, options: RelationOptions & {
+  through: string;
+} & {
+  pivotExtras?: string[];
+}): Relation;
+declare function hasManyThrough(relatedThunk: () => ModelDefinition, throughThunk: () => ModelDefinition, options?: RelationOptions): Relation;
+//#endregion
+//#region src/relations/morph.d.ts
+interface MorphToOptions {
+  /** Base name for the polymorphic relation (e.g. "commentable" → commentableType, commentableId) */
+  name: string;
+  /** Custom type column name. Default: `${name}Type` */
+  type?: string;
+  /** Custom id column name. Default: `${name}Id` */
+  id?: string;
+  /**
+   * Registry mapping type column values to model definition thunks.
+   * Example: { posts: () => Post, videos: () => Video }
+   * This is required for runtime resolution.
+   */
+  morphMap?: Record<string, () => ModelDefinition>;
+}
+interface MorphManyOptions {
+  name: string;
+  related: () => ModelDefinition;
+  type?: string;
+  id?: string;
+  /**
+   * The value stored in the type column for this parent model.
+   * Should be unique per parent model type (e.g. the parent's table name).
+   * If omitted, defaults to the child's table name (the `related` model's table).
+   */
+  typeValue?: string;
+}
+interface MorphOneOptions {
+  name: string;
+  related: () => ModelDefinition;
+  type?: string;
+  id?: string;
+  typeValue?: string;
+}
+/**
+ * Resolve the related model for a MorphTo relation given a parent instance.
+ * Looks up the parent's `{name}Type` column value in the relation's morphMap
+ * and returns the corresponding ModelDefinition.
+ *
+ * Returns `undefined` if the type column is null, the morph map entry is
+ * missing, or the relation is not a morphTo.
+ */
+declare function resolveMorphRelation(relation: Relation, parent: ModelInstance): ModelDefinition | undefined;
+/**
+ * Define a polymorphic belongsTo relationship.
+ *
+ * Requires a `morphMap` to resolve the related model class at runtime
+ * based on the value of the type column.
+ *
+ * ### Usage
+ * ```ts
+ * Comment.relations.commentable = defineMorphTo({
+ *   name: "commentable",
+ *   morphMap: {
+ *     posts: () => Post,
+ *     videos: () => Video,
+ *   },
+ * })
+ * ```
+ *
+ * Eager loading groups parents by type and issues one query per type:
+ * ```ts
+ * const comments = await Comment.query().with("commentable")
+ * // → SELECT * FROM comments
+ * // → SELECT * FROM posts WHERE id IN (...)
+ * // → SELECT * FROM videos WHERE id IN (...)
+ * ```
+ */
+declare function defineMorphTo(options: MorphToOptions): Relation;
+/**
+ * Define a polymorphic hasMany relationship.
+ * The related table stores the parent's type and id.
+ */
+declare function defineMorphMany(options: MorphManyOptions): Relation;
+/**
+ * Define a polymorphic hasOne relationship.
+ */
+declare function defineMorphOne(options: MorphOneOptions): Relation;
+//#endregion
+export { Attribute, type Collection, type Column, type ColumnShape, type ColumnTypes, type ColumnValue, type Constraint, DatabaseError, type DatabaseErrorCode, type HookCallback, type HookManager, type InsertGraphOptions, type LifecycleEvent, type ModelConfig, type ModelDefinition, type ModelId, type ModelInstance, ModelNotFoundError, ModelNotRegisteredError, type MorphManyOptions, type MorphOneOptions, type MorphToOptions, type ORMConfig, type ORMLike, type PaginatedResult, type Paginator, type PaginatorJson, type Plugin, type QueryBuilder, type Relation, RelationNotAllowedError, RelationNotFoundError, type RelationOptions, type RelationType, type SchemaConfig, type UpsertGraphOptions, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, defineModel, defineMorphMany, defineMorphOne, defineMorphTo, hasMany, hasManyThrough, hasOne, manyToMany, normalizeError, resolveMorphRelation, softDeletes, t, timestamps, ulid };