@prisma-idb/client-idb 0.9.1 → 0.11.0

package/dist/idb-orm-9XN3c9ly.d.mts

@@ -0,0 +1,399 @@
+import { C as NoIncludes, D as ReferenceRelKeys, E as PatchInput, M as SelectedRow, O as RelatedModelOf, P as WhereFilter, S as MutationUpdateInput, T as OrderBySpec, a as IdbAggregateBuilder, c as IdbAggregateSpec, g as IncludeSpec, i as DefaultModelRow, l as IdbContract, o as IdbAggregateResult, p as IdbStorage, r as CreateInput, t as IdbQueryExecutor, v as KeyType, x as MutationCreateInput } from "./executor-Bp-hdRg2.mjs";
+import { AsyncIterableResult } from "@prisma/orm-framework/components/runtime";
+import { IdbFieldFilter, IdbFilterExpr, IdbNullCheckExpr } from "@prisma-idb/adapter-idb/runtime";
+import { Contract } from "@prisma/orm-framework/contract/types";
+//#region src/core/model-accessor.d.ts
+/**
+ * Operator surface available on every field. All return frozen AST nodes
+ * — they are values, not statements, so chaining and logical combinators
+ * compose naturally.
+ */
+interface IdbFieldAccessor<T> {
+  eq(value: T): IdbFieldFilter;
+  neq(value: T): IdbFieldFilter;
+  gt(value: T): IdbFieldFilter;
+  lt(value: T): IdbFieldFilter;
+  gte(value: T): IdbFieldFilter;
+  lte(value: T): IdbFieldFilter;
+  in(values: ReadonlyArray<T>): IdbFieldFilter;
+  notIn(values: ReadonlyArray<T>): IdbFieldFilter;
+  contains(sub: string): IdbFieldFilter;
+  startsWith(sub: string): IdbFieldFilter;
+  endsWith(sub: string): IdbFieldFilter;
+  isNull(): IdbNullCheckExpr;
+  isNotNull(): IdbNullCheckExpr;
+}
+/**
+ * The accessor object handed to a `where(fn)` callback. Each key resolves
+ * to an {@link IdbFieldAccessor} typed against the field's output type.
+ *
+ * The Proxy makes every string key resolve to an accessor at runtime; the
+ * type narrows the visible surface to the model's declared fields so the
+ * developer gets autocomplete.
+ */
+type IdbModelAccessor<TContract, ModelName extends string> = { readonly [K in keyof DefaultModelRow<TContract, ModelName>]-?: IdbFieldAccessor<DefaultModelRow<TContract, ModelName>[K]>; };
+//#endregion
+//#region src/core/store-state.d.ts
+/**
+ * One entry in {@link IdbAccessorState.includes} — describes how a single
+ * `.include()`d relation should be materialised.
+ *
+ * - `collection`: load the related rows, applying the refined `state`
+ *   (its `filters` / `orderBy` / `skip` / `take`) to the child scan.
+ *   `state` is `emptyAccessorState()` for an unrefined `.include(rel)`.
+ * - `scalar`: reduce the related rows to a single number (Phase 6.5 supports
+ *   `count`). The `state.filters` still constrain which children are counted.
+ *
+ * Mirrors the `IncludeExpr` / `IncludeScalar` split from
+ * Prisma ORM's SQL client, collapsed to the two shapes IDB
+ * needs (no SQL column mapping, no `combine()` branches).
+ */
+type IncludeEntry = {
+  readonly kind: "collection";
+  readonly state: IdbAccessorState;
+} | {
+  readonly kind: "scalar";
+  readonly fn: "count";
+  readonly state: IdbAccessorState;
+};
+/**
+ * Marker returned by the child accessor's `.count()` terminal when it is
+ * called inside an `include()` refinement callback. Carries the refined
+ * child `state` so the relation loader counts only the matching children.
+ *
+ * Detected by {@link isIncludeScalar}; mirrors `IncludeScalar` from the
+ * vendor `sql-orm-client/include-descriptors.ts`.
+ */
+interface IdbIncludeScalar {
+  readonly kind: "includeScalar";
+  readonly fn: "count";
+  readonly state: IdbAccessorState;
+}
+/**
+ * Immutable state carried by each {@link IdbStoreAccessorImpl} node in the
+ * builder chain.
+ *
+ * Every mutating method (`.where()`, `.take()`, etc.) returns a cloned
+ * instance with an updated state rather than mutating in place, making the
+ * accessor safe to reuse across multiple query branches.
+ */
+interface IdbAccessorState {
+  /**
+   * Accumulated filter expressions. Multiple `.where()` calls compose
+   * with AND semantics — the planner wraps them in an `andExpr` when
+   * lowering. Each entry is already either an `IdbFieldFilter`, a
+   * combinator, or a `null-check` node — never raw shorthand records.
+   */
+  readonly filters: ReadonlyArray<IdbFilterExpr>;
+  /** Sort spec: field → direction. Applied as an in-memory comparator. */
+  readonly orderBy?: Record<string, "asc" | "desc">;
+  /** OFFSET (number of rows to skip). */
+  readonly skip?: number;
+  /** LIMIT (maximum number of rows to return). */
+  readonly take?: number;
+  /**
+   * Relations that have been `.include()`d — keys are relation names, values
+   * describe how to materialise each (collection vs scalar count, plus any
+   * refinement state). See {@link IncludeEntry}.
+   */
+  readonly includes: Record<string, IncludeEntry>;
+  /**
+   * Fields kept by `.select()`. `undefined` means "all fields". When set,
+   * the materialised rows are projected down to these fields (plus any
+   * included relation keys) after the scan and relation loads complete.
+   */
+  readonly selectedFields?: ReadonlyArray<string>;
+}
+//#endregion
+//#region src/core/grouped-accessor.d.ts
+/**
+ * One grouped-aggregate result row: the group-key fields picked from the model
+ * row, intersected with the aggregate aliases.
+ */
+type GroupedResultRow<TContract, ModelName extends string, Fields extends readonly string[], Spec extends IdbAggregateSpec> = Pick<DefaultModelRow<TContract, ModelName>, Fields[number] & keyof DefaultModelRow<TContract, ModelName>> & IdbAggregateResult<Spec>;
+/**
+ * Grouped-aggregate builder returned by `accessor.groupBy(...)`.
+ *
+ * Port of the vendor `GroupedCollection` (`sql-orm-client/grouped-collection.ts`),
+ * but purely in-memory: there is no SQL compilation, so `aggregate()`
+ * materialises the matching rows, partitions them by the group-key fields, and
+ * reduces each partition with the requested selectors.
+ */
+interface IdbGroupedAccessor<TContract, ModelName extends string, Fields extends readonly string[]> {
+  /**
+   * Reduce each group to one row of `{ ...groupKeyFields, ...aggregates }`.
+   *
+   * @example
+   * ```ts
+   * const byUser = await db.posts
+   *   .where({ published: true })
+   *   .groupBy("authorId")
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum("views") }));
+   * // [{ authorId: "u1", count: 3, totalViews: 120 }, ...]
+   * ```
+   */
+  aggregate<Spec extends IdbAggregateSpec>(fn: (agg: IdbAggregateBuilder<TContract, ModelName>) => Spec): Promise<Array<GroupedResultRow<TContract, ModelName, Fields, Spec>>>;
+}
+//#endregion
+//#region src/core/store-accessor.d.ts
+/** Callback form of `.where(fn)` — receives the typed model accessor proxy. */
+type WhereCallback<TContract, ModelName extends string> = (m: IdbModelAccessor<TContract, ModelName>) => IdbFilterExpr;
+/** Tuple of one-or-more field names of a model (for `select()` / `groupBy()`). */
+type FieldTuple<TContract, ModelName extends string> = readonly [keyof DefaultModelRow<TContract, ModelName> & string, ...(keyof DefaultModelRow<TContract, ModelName> & string)[]];
+/**
+ * The child accessor handed to an `include()` refinement callback.
+ *
+ * Exposes the chainable narrowing methods (`where` / `orderBy` / `take` /
+ * `skip`) plus the scalar `count()` reducer. Mirrors the vendor
+ * `IncludeRefinementCollection`: chainable methods return the same refinement
+ * surface so `count()` stays reachable after a `where()`, and `count()` returns
+ * an {@link IdbIncludeScalar} marker rather than the async terminal `count()`
+ * found on the top-level accessor.
+ */
+interface IdbIncludeRefinementAccessor<TContract, ModelName extends string> {
+  where(filter: WhereFilter<TContract, ModelName> | WhereCallback<TContract, ModelName>): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  orderBy(spec: OrderBySpec<TContract, ModelName>): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  take(n: number): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  skip(n: number): IdbIncludeRefinementAccessor<TContract, ModelName>;
+  count(): IdbIncludeScalar;
+}
+/** Refinement callback type for a given relation key `K`. */
+type IncludeRefineFn<TContract, ModelName extends string, K extends string, R> = (collection: IdbIncludeRefinementAccessor<TContract, RelatedModelOf<TContract, ModelName, K>>) => R;
+/**
+ * Immutable query-builder for a single IDB object store.
+ *
+ * Each method that narrows the query (`.where()`, `.take()`, etc.) returns a
+ * new, independent accessor instance — the original is never mutated. This
+ * mirrors the `MongoCollection` pattern from Prisma ORM's Mongo family.
+ *
+ * @template TContract   - The full IDB contract (with or without type maps).
+ * @template ModelName   - The model (store) this accessor targets.
+ * @template TIncludes   - Tracks which relations have been included via
+ *   `.include()` calls, so the return type widens progressively.
+ * @template TSelected   - Field names kept by `.select()`. `never` (the
+ *   default) means "all fields"; otherwise the row narrows to these fields
+ *   (plus any included relations).
+ */
+interface IdbStoreAccessor<TContract, ModelName extends string, TIncludes extends IncludeSpec<TContract, ModelName> = NoIncludes, TSelected extends string = never> {
+  /**
+   * Add a filter (ANDed with any previous `.where()` calls).
+   *
+   * Two forms:
+   *
+   * - **Shorthand**: `where({ field: value })` — multi-key shorthand
+   *   objects compose as AND. `null` values become null-checks rather
+   *   than literal-null equalities so absent fields match.
+   * - **Callback**: `where((m) => m.field.op(value))` — receives the
+   *   typed model accessor proxy and returns an `IdbFilterExpr` built
+   *   via the operator surface. Combinators (`and`, `or`, `not` from
+   *   `@prisma-idb/client-idb/orm`) compose nodes.
+   */
+  where(filter: WhereFilter<TContract, ModelName> | WhereCallback<TContract, ModelName>): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Set the sort order. Replaces any previous `.orderBy()` call. */
+  orderBy(spec: OrderBySpec<TContract, ModelName>): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Limit the number of rows returned. */
+  take(n: number): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /** Skip the first `n` rows (OFFSET). */
+  skip(n: number): IdbStoreAccessor<TContract, ModelName, TIncludes, TSelected>;
+  /**
+   * Include a reference relation in the returned rows.
+   *
+   * The relation is loaded via a single batch lookup after the main
+   * query — O(1) round trips to IDB per included relation regardless of
+   * the number of parent rows. The return type gains the relation field
+   * automatically.
+   *
+   * An optional refinement callback narrows the loaded relation:
+   *
+   * - return the (chained) collection to apply `where` / `orderBy` /
+   *   `take` / `skip` to the related rows (per-parent for `1:N`);
+   * - return `collection.count()` to reduce a to-many relation to the
+   *   number of matching children (the field becomes a `number`).
+   *
+   * @example
+   * ```ts
+   * db.users.include("posts", (posts) => posts.where({ published: true }).take(5))
+   * db.users.include("posts", (posts) => posts.count())
+   * ```
+   */
+  include<K extends ReferenceRelKeys<TContract, ModelName>>(relation: K, refineFn?: IncludeRefineFn<TContract, ModelName, K, IdbIncludeRefinementAccessor<TContract, RelatedModelOf<TContract, ModelName, K>>>): IdbStoreAccessor<TContract, ModelName, TIncludes & Record<K, true>, TSelected>;
+  include<K extends ReferenceRelKeys<TContract, ModelName>>(relation: K, refineFn: IncludeRefineFn<TContract, ModelName, K, IdbIncludeScalar>): IdbStoreAccessor<TContract, ModelName, TIncludes & Record<K, "scalar">, TSelected>;
+  /**
+   * Project the row down to a subset of scalar fields. Any previously
+   * `.include()`d relations are preserved on the result; only the scalar
+   * fields are narrowed.
+   *
+   * @example
+   * ```ts
+   * const summaries = await db.users.select("id", "email").all();
+   * // typeof summaries[number] === { id: string; email: string }
+   * ```
+   */
+  select<Fields extends FieldTuple<TContract, ModelName>>(...fields: Fields): IdbStoreAccessor<TContract, ModelName, TIncludes, Fields[number]>;
+  /** Return all matching rows as an async iterable (also awaitable as `Row[]`). */
+  all(): AsyncIterableResult<SelectedRow<TContract, ModelName, TIncludes, TSelected>>;
+  /** Return the first matching row, or `null` if none match. */
+  first(): Promise<SelectedRow<TContract, ModelName, TIncludes, TSelected> | null>;
+  /**
+   * Run an in-memory aggregate (count/sum/avg/min/max) over the rows matching
+   * the accumulated `.where()` filter. Returns one result object keyed by the
+   * aliases supplied in the spec.
+   *
+   * @example
+   * ```ts
+   * const stats = await db.posts.where({ published: true }).aggregate((agg) => ({
+   *   total: agg.count(),
+   *   avgViews: agg.avg("views"),
+   * }));
+   * ```
+   */
+  aggregate<Spec extends IdbAggregateSpec>(fn: (agg: IdbAggregateBuilder<TContract, ModelName>) => Spec): Promise<IdbAggregateResult<Spec>>;
+  /**
+   * Switch to grouped-aggregate mode. The returned {@link IdbGroupedAccessor}'s
+   * `.aggregate(...)` terminal produces one row per group with the chosen key
+   * fields plus the requested aggregates.
+   *
+   * @example
+   * ```ts
+   * const byUser = await db.posts
+   *   .where({ published: true })
+   *   .groupBy("authorId")
+   *   .aggregate((agg) => ({ count: agg.count(), totalViews: agg.sum("views") }));
+   * ```
+   */
+  groupBy<Fields extends FieldTuple<TContract, ModelName>>(...fields: Fields): IdbGroupedAccessor<TContract, ModelName, Fields>;
+  /**
+   * Insert a record into the store and return the stored row.
+   *
+   * The primary key field is optional in `data` — pass it to use a
+   * client-generated ID (`cuid`, `uuid`) or omit it for auto-increment stores.
+   *
+   * Relation fields accept a mutation callback:
+   * `posts: (rel) => rel.create([...])` or `author: (rel) => rel.connect({ id })`.
+   * When any relation callback is present, all writes are wrapped in a single
+   * multi-store IDB transaction (requires IdbRuntime, not a plain executor).
+   */
+  create(data: MutationCreateInput<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName>>;
+  /** Look up a single row by primary key. Returns `null` if not found. */
+  findUnique(key: KeyType<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName> | null>;
+  /** Delete the row with the given primary key. */
+  delete(key: KeyType<TContract, ModelName>): Promise<void>;
+  /**
+   * Update the first row matching the accumulated `.where()` filter.
+   * Returns the merged row, or `null` if no row matches.
+   *
+   * Relation fields accept `connect` or `disconnect` callbacks. When any
+   * relation callback is present, all writes run in a single multi-store
+   * IDB transaction (requires IdbRuntime).
+   */
+  update(patch: MutationUpdateInput<TContract, ModelName>): Promise<DefaultModelRow<TContract, ModelName> | null>;
+  /**
+   * Update all rows matching the accumulated `.where()` filter and return
+   * them as an `AsyncIterableResult` (also awaitable as `Row[]`).
+   */
+  updateAll(patch: PatchInput<TContract, ModelName>): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Update all rows matching the accumulated `.where()` filter.
+   * Returns the count of updated rows.
+   */
+  updateCount(patch: PatchInput<TContract, ModelName>): Promise<number>;
+  /**
+   * Insert or update a single record.
+   *
+   * - If a row matching `where` exists: shallow-merge `update` onto it and
+   *   return the merged row.
+   * - If no matching row exists: insert `create` and return it.
+   */
+  upsert(args: {
+    create: CreateInput<TContract, ModelName>;
+    update: PatchInput<TContract, ModelName>;
+    where: WhereFilter<TContract, ModelName>;
+  }): Promise<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Insert multiple records in a single atomic transaction.
+   * Returns all inserted rows as an `AsyncIterableResult`.
+   */
+  createAll(data: CreateInput<TContract, ModelName>[]): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Insert multiple records in a single atomic transaction.
+   * Returns the count of inserted rows.
+   */
+  createCount(data: CreateInput<TContract, ModelName>[]): Promise<number>;
+  /**
+   * Delete all rows matching the accumulated `.where()` filter.
+   * Returns the deleted rows as an `AsyncIterableResult`.
+   */
+  deleteAll(): AsyncIterableResult<DefaultModelRow<TContract, ModelName>>;
+  /**
+   * Delete all rows matching the accumulated `.where()` filter.
+   * Returns the count of deleted rows.
+   */
+  deleteCount(): Promise<number>;
+  /**
+   * Count all rows matching the accumulated `.where()` filter.
+   * With no filter, counts all rows in the store.
+   *
+   * **Note — `skip`/`take` are respected**: unlike Prisma's SQL `count()`,
+   * which ignores pagination, this implementation reuses the same planned row
+   * read as `all()`. That means `where(...).take(5).count()` returns at most 5,
+   * not the total number of matching rows. Use `where(...).count()` without
+   * `take`/`skip` when you need an unbounded total.
+   */
+  count(): Promise<number>;
+}
+//#endregion
+//#region src/core/idb-orm.d.ts
+/**
+ * The ORM client object returned by {@link idbOrm}.
+ *
+ * Keys are the root keys from `contract.roots` (e.g. `"users"`, `"posts"`).
+ * Each value is an {@link IdbStoreAccessor} targeting the corresponding model.
+ *
+ * @example
+ * ```ts
+ * const db = idbOrm({ contract, executor: runtime });
+ * const users = await db.users.all(); // IdbStoreAccessor<..., "User">
+ * ```
+ */
+type IdbOrmClient<TContract extends Contract<IdbStorage>> = { readonly [K in string & keyof TContract["roots"]]: TContract["roots"][K] extends {
+  model: infer ModelName extends string;
+} ? IdbStoreAccessor<TContract, ModelName> : never; };
+/**
+ * Options for {@link idbOrm}.
+ */
+interface IdbOrmOptions<TContract extends IdbContract> {
+  /** The resolved IDB contract (with or without attached type maps). */
+  readonly contract: TContract;
+  /**
+   * The query executor.
+   *
+   * Any object with a compatible `query()` signature satisfies this —
+   * most commonly an `IdbRuntime` created via `createIdbRuntime()`.
+   */
+  readonly executor: IdbQueryExecutor;
+}
+/**
+ * Create a typed IDB ORM client from a contract and executor.
+ *
+ * The client exposes one `IdbStoreAccessor` per entry in `contract.roots`.
+ * Only roots-declared stores are accessible at the top level — other stores
+ * can be reached via `.include()` on any accessor.
+ *
+ * @example
+ * ```ts
+ * import { idbOrm } from "@prisma-idb/client-idb/orm";
+ * import { createIdbRuntime } from "@prisma-idb/runtime-idb/runtime";
+ * import contract from "./prisma/idb-contract";
+ *
+ * const runtime = createIdbRuntime({ adapter, driver });
+ * const db = idbOrm({ contract, executor: runtime });
+ *
+ * // Typed query builder:
+ * const alice = await db.users.where({ email: "alice@example.com" }).first();
+ * const postsWithAuthor = await db.posts.include("author").all();
+ * ```
+ */
+declare function idbOrm<TContract extends IdbContract>(options: IdbOrmOptions<TContract>): IdbOrmClient<TContract>;
+//#endregion
+export { IdbStoreAccessor as a, IdbGroupedAccessor as c, IdbModelAccessor as d, IdbIncludeRefinementAccessor as i, IdbIncludeScalar as l, IdbOrmOptions as n, WhereCallback as o, idbOrm as r, GroupedResultRow as s, IdbOrmClient as t, IdbFieldAccessor as u };
+//# sourceMappingURL=idb-orm-9XN3c9ly.d.mts.map

package/dist/idb-orm-9XN3c9ly.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idb-orm-9XN3c9ly.d.mts","names":[],"sources":["../src/core/model-accessor.ts","../src/core/store-state.ts","../src/core/grouped-accessor.ts","../src/core/store-accessor.ts","../src/core/idb-orm.ts"],"mappings":"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"}