@atscript/db-client 0.1.43

package/README.md

@@ -0,0 +1,66 @@
+<p align="center">
+  <img src="https://db.atscript.dev/logo.svg" alt="Atscript" width="120" />
+</p>
+
+<h1 align="center">@atscript/db-client</h1>
+
+<p align="center">
+  Browser-compatible HTTP client for <code>@atscript/moost-db</code> REST endpoints.
+</p>
+
+<p align="center">
+  <a href="https://db.atscript.dev">Documentation</a> · <a href="https://db.atscript.dev/http/client">HTTP Client Guide</a>
+</p>
+
+---
+
+Type-safe HTTP client that mirrors the server-side `AtscriptDbTable` API over REST. Works in browsers, Node.js, and any runtime with `fetch`. Supports the full query surface — filters, sorting, pagination, relation loading, text search, and aggregation.
+
+## Installation
+
+```bash
+pnpm add @atscript/db-client
+```
+
+## Quick Start
+
+```typescript
+import { Client } from "@atscript/db-client";
+import type { User } from "./models/user.as";
+
+const users = new Client<typeof User>("/api/users", {
+  baseUrl: "https://api.example.com",
+});
+
+// Query
+const active = await users.findMany({ filter: { status: "active" } });
+const user = await users.findById("abc-123");
+
+// Write
+const { insertedId } = await users.insertOne({ name: "Alice" });
+await users.updateOne({ id: insertedId, role: "admin" });
+await users.deleteOne(insertedId);
+
+// Metadata
+const meta = await users.meta();
+```
+
+## Features
+
+- **Full CRUD** — `findMany`, `findOne`, `findById`, `count`, `pages`, `insertOne`, `insertMany`, `updateOne`, `bulkUpdate`, `replaceOne`, `bulkReplace`, `deleteOne`
+- **URL query syntax** — filtering, sorting, pagination, field selection, relation loading via `$with`
+- **Search** — full-text (`search()`) and vector search via query controls
+- **Aggregation** — `$groupBy` with aggregate functions
+- **Error handling** — `ClientError` with structured validation errors
+- **SSR isomorphism** — `DbInterface<T>` shared between server `AtscriptDbTable` and client `Client`
+- **Configurable** — custom `fetch`, static or async headers, base URL
+
+## Documentation
+
+- [HTTP Client Guide](https://db.atscript.dev/http/client) — Full API reference with examples
+- [HTTP API Guide](https://db.atscript.dev/http/) — Server-side setup
+- [URL Query Syntax](https://db.atscript.dev/http/query-syntax) — Filter, sort, and pagination syntax
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,197 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _uniqu_url_builder = require("@uniqu/url/builder");
+//#region src/client-error.ts
+/**
+* Error thrown by `Client` when the server responds with a non-2xx status code.
+* Captures the HTTP status and the structured error body from moost-db.
+*/
+var ClientError = class extends Error {
+	name = "ClientError";
+	constructor(status, body) {
+		super(body.message || `HTTP ${status}`);
+		this.status = status;
+		this.body = body;
+	}
+	/** Shortcut to structured validation/DB errors from the server. */
+	get errors() {
+		return this.body.errors ?? [];
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* Browser-compatible HTTP client for moost-db REST endpoints.
+*
+* Two usage modes (same class, different generic):
+* ```typescript
+* // Untyped — broad Record<string, unknown> typing
+* const users = new Client('/db/tables/users')
+*
+* // Type-safe — Atscript type as generic parameter
+* const users = new Client<typeof User>('/db/tables/users')
+* ```
+*/
+var Client = class {
+	_path;
+	_baseUrl;
+	_fetch;
+	_headers;
+	_metaPromise;
+	constructor(path, opts) {
+		this._path = path.endsWith("/") ? path.slice(0, -1) : path;
+		this._baseUrl = opts?.baseUrl ?? "";
+		this._fetch = opts?.fetch ?? globalThis.fetch.bind(globalThis);
+		this._headers = opts?.headers;
+	}
+	async findOne(query) {
+		const controls = {
+			...query?.controls,
+			$limit: 1
+		};
+		return (await this._get("query", {
+			...query,
+			controls
+		}))[0] ?? null;
+	}
+	async findMany(query) {
+		return this._get("query", query);
+	}
+	async findById(id, query) {
+		if (id !== null && typeof id === "object") {
+			const params = this._idToParams(id);
+			if (query?.controls) {
+				const controlStr = (0, _uniqu_url_builder.buildUrl)({ controls: query.controls });
+				if (controlStr) for (const [k, v] of new URLSearchParams(controlStr)) params.set(k, v);
+			}
+			const qs = params.toString();
+			try {
+				return await this._request("GET", `one${qs ? `?${qs}` : ""}`);
+			} catch (e) {
+				if (e instanceof ClientError && e.status === 404) return null;
+				throw e;
+			}
+		}
+		const controlStr = query?.controls ? (0, _uniqu_url_builder.buildUrl)({ controls: query.controls }) : "";
+		try {
+			return await this._request("GET", `one/${encodeURIComponent(String(id))}${controlStr ? `?${controlStr}` : ""}`);
+		} catch (e) {
+			if (e instanceof ClientError && e.status === 404) return null;
+			throw e;
+		}
+	}
+	async count(query) {
+		const controls = {
+			...query?.controls,
+			$count: true
+		};
+		return this._get("query", {
+			...query,
+			controls
+		});
+	}
+	async findManyWithCount(query) {
+		const controls = query?.controls ?? {};
+		const limit = controls.$limit || 1e3;
+		const skip = controls.$skip || 0;
+		const page = Math.floor(skip / limit) + 1;
+		const result = await this._get("pages", {
+			...query,
+			controls: {
+				...controls,
+				$page: page,
+				$size: limit
+			}
+		});
+		return {
+			data: result.data,
+			count: result.count
+		};
+	}
+	async pages(query) {
+		return this._get("pages", query);
+	}
+	async search(text, query, indexName) {
+		const controls = {
+			...query?.controls,
+			$search: text
+		};
+		if (indexName) controls.$index = indexName;
+		return this._get("query", {
+			...query,
+			controls
+		});
+	}
+	async aggregate(query) {
+		return this._get("query", query);
+	}
+	async insertOne(data) {
+		return this._request("POST", "", data);
+	}
+	async insertMany(data) {
+		return this._request("POST", "", data);
+	}
+	async updateOne(data) {
+		return this._request("PATCH", "", data);
+	}
+	async bulkUpdate(data) {
+		return this._request("PATCH", "", data);
+	}
+	async replaceOne(data) {
+		return this._request("PUT", "", data);
+	}
+	async bulkReplace(data) {
+		return this._request("PUT", "", data);
+	}
+	async deleteOne(id) {
+		if (id !== null && typeof id === "object") return this._request("DELETE", `?${this._idToParams(id).toString()}`);
+		return this._request("DELETE", encodeURIComponent(String(id)));
+	}
+	async meta() {
+		if (!this._metaPromise) this._metaPromise = this._request("GET", "meta");
+		return this._metaPromise;
+	}
+	_idToParams(id) {
+		const params = new URLSearchParams();
+		for (const [k, v] of Object.entries(id)) params.set(k, String(v));
+		return params;
+	}
+	async _get(endpoint, query) {
+		const qs = query ? (0, _uniqu_url_builder.buildUrl)(query) : "";
+		return this._request("GET", `${endpoint}${qs ? `?${qs}` : ""}`);
+	}
+	async _resolveHeaders() {
+		if (!this._headers) return {};
+		if (typeof this._headers === "function") return await this._headers();
+		return this._headers;
+	}
+	async _request(method, endpoint, body) {
+		const sep = endpoint && !endpoint.startsWith("?") ? "/" : "";
+		const url = `${this._baseUrl}${this._path}${sep}${endpoint}`;
+		const headers = { ...await this._resolveHeaders() };
+		const init = {
+			method,
+			headers
+		};
+		if (body !== void 0) {
+			headers["Content-Type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		const res = await this._fetch(url, init);
+		if (!res.ok) {
+			let errorBody;
+			try {
+				errorBody = await res.json();
+			} catch {
+				errorBody = {
+					message: res.statusText,
+					statusCode: res.status
+				};
+			}
+			throw new ClientError(res.status, errorBody);
+		}
+		return res.json();
+	}
+};
+//#endregion
+exports.Client = Client;
+exports.ClientError = ClientError;

package/dist/index.d.cts

@@ -0,0 +1,398 @@
+//#region ../../node_modules/.pnpm/@uniqu+core@0.1.2/node_modules/@uniqu/core/dist/index.d.ts
+/** All comparison operators supported by the filter format. */
+type ComparisonOp = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$regex' | '$exists';
+/**
+ * Per-field typed operator map. When `V` is the field's value type, operators
+ * are constrained accordingly:
+ * - `$regex` is only available when `V` extends `string`
+ * - `$gt/$gte/$lt/$lte` are only available when `V` extends `number | string | Date`
+ */
+type FieldOpsFor<V> = {
+  $eq?: V;
+  $ne?: V;
+  $in?: V[];
+  $nin?: V[];
+  $exists?: boolean;
+} & (V extends string ? {
+  $regex?: RegExp | string;
+} : {}) & (V extends number | string | Date ? {
+  $gt?: V;
+  $gte?: V;
+  $lt?: V;
+  $lte?: V;
+} : {});
+/** Untyped operator map. */
+/**
+ * A filter expression is either a comparison leaf or a logical branch.
+ * `T` is the entity shape — provides type-safe field names and value types.
+ * Defaults to `Record<string, unknown>` (untyped).
+ */
+type FilterExpr<T = Record<string, unknown>> = ComparisonNode<T> | LogicalNode<T>;
+/**
+ * Leaf node: one or more field comparisons.
+ * When `T` is typed, only known keys are allowed.
+ * When untyped (default), any string key is accepted.
+ */
+type ComparisonNode<T = Record<string, unknown>> = { [K in keyof T & string]?: T[K] | FieldOpsFor<T[K]> };
+/**
+ * Branch node: logical combination of child expressions.
+ * Each variant forbids the other logical keys via `never` to prevent
+ * mixing comparison fields with logical operators at the type level.
+ */
+type LogicalNode<T = Record<string, unknown>> = {
+  $and: FilterExpr<T>[];
+  $or?: never;
+  $not?: never;
+} | {
+  $or: FilterExpr<T>[];
+  $and?: never;
+  $not?: never;
+} | {
+  $not: FilterExpr<T>;
+  $and?: never;
+  $or?: never;
+};
+/** Known aggregate function names. Consumers may support additional functions via the (string & {}) escape hatch. */
+type AggregateFn = 'sum' | 'count' | 'avg' | 'min' | 'max';
+/** A single aggregate function call within $select. Generic params preserve literal types for result inference. */
+interface AggregateExpr<Fn extends string = AggregateFn | (string & {}), Field extends string = string, Alias extends string = string> {
+  /** Function name (sum, count, avg, min, max, or custom). */
+  $fn: Fn;
+  /** Field to aggregate. '*' for count(*). */
+  $field: Field;
+  /** Alias for the result. Auto-generated by URL parser if omitted. */
+  $as?: Alias;
+}
+/**
+ * Projection definition.
+ * - Array form: inclusion list with optional aggregates.
+ *   Plain strings select fields; AggregateExpr objects define computed columns.
+ * - Object form: inclusion/exclusion map (0 or 1 per field). No aggregates in this form.
+ */
+type SelectExpr<T = Record<string, unknown>> = ((keyof T & string) | AggregateExpr)[] | Partial<Record<keyof T & string, 0 | 1>>;
+/** Query controls (pagination, projection, sorting, grouping). Generic `T` constrains field names. */
+interface UniqueryControls<T = Record<string, unknown>, Nav extends Record<string, unknown> = Record<string, unknown>> {
+  $sort?: Partial<Record<keyof T & string, 1 | -1>>;
+  $skip?: number;
+  $limit?: number;
+  $count?: boolean;
+  $select?: SelectExpr<T>;
+  /** Fields to group by for aggregate queries. */
+  $groupBy?: (keyof T & string)[];
+  /** Post-aggregation filter. Operates on aggregate aliases and dimension fields. */
+  $having?: FilterExpr;
+  /** Relations to populate alongside the query. */
+  $with?: TypedWithRelation<Nav>[];
+  /** Pass-through for unknown $-prefixed keywords. */
+  [key: `$${string}`]: unknown;
+}
+/**
+ * Canonical query representation.
+ * When `name` is present this is a nested relation (sub-query inside `$with`).
+ * When absent it is the root query.
+ */
+interface Uniquery<T = Record<string, unknown>, Nav extends Record<string, unknown> = Record<string, unknown>> {
+  /** Relation name. Present only for nested `$with` sub-queries. */
+  name?: string;
+  filter?: FilterExpr<T>;
+  controls?: UniqueryControls<T, Nav>;
+  /** Pre-computed insights. */
+  insights?: UniqueryInsights;
+}
+/** Unwrap array types to get the element type for nav props. */
+type NavTarget<T> = T extends Array<infer U> ? U : T;
+/**
+ * A typed $with relation entry.
+ * When Nav is typed (from __navProps), name is constrained to known nav prop keys.
+ * Each entry gets its own filter/controls typed to the target entity.
+ * Falls back to untyped WithRelation when Nav has no known keys.
+ */
+type TypedWithRelation<Nav extends Record<string, unknown>> = [keyof Nav & string] extends [never] ? WithRelation | string : { [K in keyof Nav & string]: {
+  name: K;
+  filter?: FilterExpr<NavTarget<Nav[K]> extends {
+    __ownProps: infer F;
+  } ? F : Record<string, unknown>>;
+  controls?: UniqueryControls<NavTarget<Nav[K]> extends {
+    __ownProps: infer F;
+  } ? F : Record<string, unknown>, NavTarget<Nav[K]> extends {
+    __navProps: infer N extends Record<string, unknown>;
+  } ? N : Record<string, unknown>>;
+  insights?: UniqueryInsights;
+} }[keyof Nav & string] | (keyof Nav & string);
+/** Untyped $with relation — used when Nav generic is not provided. */
+type WithRelation = {
+  name: string;
+  filter?: FilterExpr;
+  controls?: UniqueryControls;
+  insights?: UniqueryInsights;
+};
+/**
+ * Insight operator includes comparison ops, control ops ($-prefixed),
+ * and aggregate function names (bare, e.g. 'sum', 'avg').
+ */
+type InsightOp = ComparisonOp | '$select' | '$order' | '$with' | '$groupBy' | '$having' | AggregateFn | (string & {});
+/** Map of field names to the set of operators used on that field. */
+type UniqueryInsights = Map<string, Set<InsightOp>>;
+/** Aggregate query controls. Separate from UniqueryControls: $groupBy is required, $with is forbidden. */
+interface AggregateControls<T = Record<string, unknown>, D extends keyof T & string = keyof T & string, M extends keyof T & string = keyof T & string> {
+  $groupBy: D[];
+  $select?: (D | AggregateExpr<AggregateFn, M | '*'>)[];
+  $having?: FilterExpr;
+  $sort?: Record<string, 1 | -1>;
+  $skip?: number;
+  $limit?: number;
+  $count?: boolean;
+  [key: `$${string}`]: unknown;
+}
+/** Aggregate query — no name (can't nest), no Nav (no $with). */
+interface AggregateQuery<T = Record<string, unknown>, D extends keyof T & string = keyof T & string, M extends keyof T & string = keyof T & string> {
+  filter?: FilterExpr<T>;
+  controls: AggregateControls<T, D, M>;
+  insights?: UniqueryInsights;
+}
+/** Resolve the output alias of an AggregateExpr. Uses $as if provided, otherwise generates {fn}_{field}. */
+//#endregion
+//#region ../../node_modules/.pnpm/@atscript+typescript@0.1.41_@atscript+core@0.1.41_@atscript+db@packages+db_@prostojs+lo_041ff52083ad05a1dfbd1c9f541c1d21/node_modules/@atscript/typescript/dist/utils.d.ts
+/** Top-level serialized annotated type. JSON-safe representation of a {@link TAtscriptAnnotatedType}. */
+interface TSerializedAnnotatedType extends TSerializedAnnotatedTypeInner {
+  /** Format version for forward compatibility */
+  $v: number;
+}
+/** Serialized annotated type node (used for nested types within the top-level). */
+interface TSerializedAnnotatedTypeInner {
+  type: TSerializedTypeDef;
+  metadata: Record<string, unknown>;
+  optional?: boolean;
+  id?: string;
+}
+interface TSerializedTypeFinal {
+  kind: '';
+  designType: string;
+  value?: string | number | boolean;
+  tags: string[];
+}
+interface TSerializedTypeObject {
+  kind: 'object';
+  props: Record<string, TSerializedAnnotatedTypeInner>;
+  propsPatterns: Array<{
+    pattern: {
+      source: string;
+      flags: string;
+    };
+    def: TSerializedAnnotatedTypeInner;
+  }>;
+  tags: string[];
+}
+interface TSerializedTypeArray {
+  kind: 'array';
+  of: TSerializedAnnotatedTypeInner;
+  tags: string[];
+}
+interface TSerializedTypeComplex {
+  kind: 'union' | 'intersection' | 'tuple';
+  items: TSerializedAnnotatedTypeInner[];
+  tags: string[];
+}
+interface TSerializedTypeRef {
+  kind: '$ref';
+  id: string;
+}
+type TSerializedTypeDef = TSerializedTypeFinal | TSerializedTypeObject | TSerializedTypeArray | TSerializedTypeComplex | TSerializedTypeRef;
+/** Context passed to {@link TSerializeOptions.processAnnotation} for each annotation entry. */
+//#endregion
+//#region src/types.d.ts
+/** Options for creating a Client instance. */
+interface ClientOptions {
+  /**
+   * Custom fetch implementation. Defaults to `globalThis.fetch`.
+   * Use this to inject auth headers, interceptors, or a custom HTTP client.
+   */
+  fetch?: typeof globalThis.fetch;
+  /**
+   * Default headers to include with every request.
+   * Can be a static object or an async factory (e.g. for refreshing auth tokens).
+   */
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+  /**
+   * Base URL prefix. Prepended to the client path for full URL construction.
+   * @example "https://api.example.com"
+   */
+  baseUrl?: string;
+}
+/** Search index metadata from the server. */
+interface SearchIndexInfo {
+  name: string;
+  description?: string;
+  type?: "text" | "vector";
+}
+/** Relation summary in meta response. */
+interface RelationInfo {
+  name: string;
+  direction: "to" | "from" | "via";
+  isArray: boolean;
+}
+/** Per-field capability flags. */
+interface FieldMeta {
+  sortable: boolean;
+  filterable: boolean;
+}
+/** Enhanced meta response from the server. */
+interface MetaResponse {
+  searchable: boolean;
+  vectorSearchable: boolean;
+  searchIndexes: SearchIndexInfo[];
+  primaryKeys: string[];
+  readOnly: boolean;
+  relations: RelationInfo[];
+  fields: Record<string, FieldMeta>;
+  type: TSerializedAnnotatedType;
+}
+interface InsertResult {
+  insertedId: unknown;
+}
+interface InsertManyResult {
+  insertedCount: number;
+  insertedIds: unknown[];
+}
+interface UpdateResult {
+  matchedCount: number;
+  modifiedCount: number;
+}
+interface DeleteResult {
+  deletedCount: number;
+}
+/** Paginated response shape (matches moost-db /pages response). */
+interface PagesResponse<T> {
+  data: T[];
+  page: number;
+  itemsPerPage: number;
+  pages: number;
+  count: number;
+}
+/** Server error response shape (matches moost-db error transform). */
+interface ServerError {
+  message: string;
+  statusCode: number;
+  errors?: Array<{
+    path: string;
+    message: string;
+    details?: unknown[];
+  }>;
+}
+/** Extract the data type from an Atscript annotated type `T`. */
+type DataOf<T> = T extends {
+  type: {
+    __dataType?: infer D;
+  };
+} ? unknown extends D ? T extends (new (...a: any[]) => infer I) ? I : Record<string, unknown> : D & Record<string, unknown> : Record<string, unknown>;
+/** Extract own (non-nav) properties from an Atscript annotated type. */
+type OwnOf<T> = T extends {
+  __ownProps: infer O;
+} ? O : DataOf<T>;
+/** Extract nav properties from an Atscript annotated type. */
+type NavOf<T> = T extends {
+  __navProps: infer N extends Record<string, unknown>;
+} ? N : Record<string, never>;
+/** Extract primary key type from an Atscript annotated type. */
+type IdOf<T> = T extends {
+  __pk: infer PK;
+} ? PK : unknown;
+/**
+ * Shared interface for both server-side `AtscriptDbTable` and client-side `Client`.
+ * Enables SSR isomorphism: same code runs on server (direct DB) and browser (HTTP).
+ *
+ * ```typescript
+ * const users: DbInterface<typeof User> = isServer ? serverTable : httpClient
+ * await users.findMany({ filter: { active: true } })
+ * ```
+ */
+interface DbInterface<T = Record<string, unknown>> {
+  findOne(query: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T> | null>;
+  findMany(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T>[]>;
+  findById(id: IdOf<T>, query?: {
+    controls?: UniqueryControls<OwnOf<T>, NavOf<T>>;
+  }): Promise<DataOf<T> | null>;
+  count(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<number>;
+  search(text: string, query?: Uniquery<OwnOf<T>, NavOf<T>>, indexName?: string): Promise<DataOf<T>[]>;
+  aggregate(query: AggregateQuery): Promise<Record<string, unknown>[]>;
+  insertOne(data: Partial<DataOf<T>>): Promise<InsertResult>;
+  insertMany(data: Partial<DataOf<T>>[]): Promise<InsertManyResult>;
+  updateOne(data: Partial<DataOf<T>>): Promise<UpdateResult>;
+  bulkUpdate(data: Partial<DataOf<T>>[]): Promise<UpdateResult>;
+  replaceOne(data: DataOf<T>): Promise<UpdateResult>;
+  bulkReplace(data: DataOf<T>[]): Promise<UpdateResult>;
+  deleteOne(id: IdOf<T>): Promise<DeleteResult>;
+}
+//#endregion
+//#region src/client.d.ts
+/**
+ * Browser-compatible HTTP client for moost-db REST endpoints.
+ *
+ * Two usage modes (same class, different generic):
+ * ```typescript
+ * // Untyped — broad Record<string, unknown> typing
+ * const users = new Client('/db/tables/users')
+ *
+ * // Type-safe — Atscript type as generic parameter
+ * const users = new Client<typeof User>('/db/tables/users')
+ * ```
+ */
+declare class Client<T = Record<string, unknown>> implements DbInterface<T> {
+  private readonly _path;
+  private readonly _baseUrl;
+  private readonly _fetch;
+  private readonly _headers?;
+  private _metaPromise?;
+  constructor(path: string, opts?: ClientOptions);
+  findOne(query: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T> | null>;
+  findMany(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T>[]>;
+  findById(id: IdOf<T>, query?: {
+    controls?: UniqueryControls<OwnOf<T>, NavOf<T>>;
+  }): Promise<DataOf<T> | null>;
+  count(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<number>;
+  findManyWithCount(query: Uniquery<OwnOf<T>, NavOf<T>>): Promise<{
+    data: DataOf<T>[];
+    count: number;
+  }>;
+  pages(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<PagesResponse<DataOf<T>>>;
+  search(text: string, query?: Uniquery<OwnOf<T>, NavOf<T>>, indexName?: string): Promise<DataOf<T>[]>;
+  aggregate(query: AggregateQuery): Promise<Record<string, unknown>[]>;
+  insertOne(data: Partial<DataOf<T>>): Promise<InsertResult>;
+  insertMany(data: Partial<DataOf<T>>[]): Promise<InsertManyResult>;
+  updateOne(data: Partial<DataOf<T>>): Promise<UpdateResult>;
+  bulkUpdate(data: Partial<DataOf<T>>[]): Promise<UpdateResult>;
+  replaceOne(data: DataOf<T>): Promise<UpdateResult>;
+  bulkReplace(data: DataOf<T>[]): Promise<UpdateResult>;
+  deleteOne(id: IdOf<T>): Promise<DeleteResult>;
+  meta(): Promise<MetaResponse>;
+  private _idToParams;
+  private _get;
+  private _resolveHeaders;
+  private _request;
+}
+//#endregion
+//#region src/client-error.d.ts
+/**
+ * Error thrown by `Client` when the server responds with a non-2xx status code.
+ * Captures the HTTP status and the structured error body from moost-db.
+ */
+declare class ClientError extends Error {
+  /** HTTP status code (e.g. 400, 404, 409, 500). */
+  readonly status: number;
+  /** Structured error response from the server. */
+  readonly body: ServerError;
+  name: string;
+  constructor(/** HTTP status code (e.g. 400, 404, 409, 500). */
+
+  status: number, /** Structured error response from the server. */
+
+  body: ServerError);
+  /** Shortcut to structured validation/DB errors from the server. */
+  get errors(): {
+    path: string;
+    message: string;
+    details?: unknown[];
+  }[];
+}
+//#endregion
+export { type AggregateQuery, Client, ClientError, type ClientOptions, type DataOf, type DbInterface, type DeleteResult, type FieldMeta, type FilterExpr, type IdOf, type InsertManyResult, type InsertResult, type MetaResponse, type NavOf, type OwnOf, type PagesResponse, type RelationInfo, type SearchIndexInfo, type ServerError, type TSerializedAnnotatedType, type TypedWithRelation, type Uniquery, type UniqueryControls, type UpdateResult };

package/dist/index.d.mts

@@ -0,0 +1,398 @@
+//#region ../../node_modules/.pnpm/@uniqu+core@0.1.2/node_modules/@uniqu/core/dist/index.d.ts
+/** All comparison operators supported by the filter format. */
+type ComparisonOp = '$eq' | '$ne' | '$gt' | '$gte' | '$lt' | '$lte' | '$in' | '$nin' | '$regex' | '$exists';
+/**
+ * Per-field typed operator map. When `V` is the field's value type, operators
+ * are constrained accordingly:
+ * - `$regex` is only available when `V` extends `string`
+ * - `$gt/$gte/$lt/$lte` are only available when `V` extends `number | string | Date`
+ */
+type FieldOpsFor<V> = {
+  $eq?: V;
+  $ne?: V;
+  $in?: V[];
+  $nin?: V[];
+  $exists?: boolean;
+} & (V extends string ? {
+  $regex?: RegExp | string;
+} : {}) & (V extends number | string | Date ? {
+  $gt?: V;
+  $gte?: V;
+  $lt?: V;
+  $lte?: V;
+} : {});
+/** Untyped operator map. */
+/**
+ * A filter expression is either a comparison leaf or a logical branch.
+ * `T` is the entity shape — provides type-safe field names and value types.
+ * Defaults to `Record<string, unknown>` (untyped).
+ */
+type FilterExpr<T = Record<string, unknown>> = ComparisonNode<T> | LogicalNode<T>;
+/**
+ * Leaf node: one or more field comparisons.
+ * When `T` is typed, only known keys are allowed.
+ * When untyped (default), any string key is accepted.
+ */
+type ComparisonNode<T = Record<string, unknown>> = { [K in keyof T & string]?: T[K] | FieldOpsFor<T[K]> };
+/**
+ * Branch node: logical combination of child expressions.
+ * Each variant forbids the other logical keys via `never` to prevent
+ * mixing comparison fields with logical operators at the type level.
+ */
+type LogicalNode<T = Record<string, unknown>> = {
+  $and: FilterExpr<T>[];
+  $or?: never;
+  $not?: never;
+} | {
+  $or: FilterExpr<T>[];
+  $and?: never;
+  $not?: never;
+} | {
+  $not: FilterExpr<T>;
+  $and?: never;
+  $or?: never;
+};
+/** Known aggregate function names. Consumers may support additional functions via the (string & {}) escape hatch. */
+type AggregateFn = 'sum' | 'count' | 'avg' | 'min' | 'max';
+/** A single aggregate function call within $select. Generic params preserve literal types for result inference. */
+interface AggregateExpr<Fn extends string = AggregateFn | (string & {}), Field extends string = string, Alias extends string = string> {
+  /** Function name (sum, count, avg, min, max, or custom). */
+  $fn: Fn;
+  /** Field to aggregate. '*' for count(*). */
+  $field: Field;
+  /** Alias for the result. Auto-generated by URL parser if omitted. */
+  $as?: Alias;
+}
+/**
+ * Projection definition.
+ * - Array form: inclusion list with optional aggregates.
+ *   Plain strings select fields; AggregateExpr objects define computed columns.
+ * - Object form: inclusion/exclusion map (0 or 1 per field). No aggregates in this form.
+ */
+type SelectExpr<T = Record<string, unknown>> = ((keyof T & string) | AggregateExpr)[] | Partial<Record<keyof T & string, 0 | 1>>;
+/** Query controls (pagination, projection, sorting, grouping). Generic `T` constrains field names. */
+interface UniqueryControls<T = Record<string, unknown>, Nav extends Record<string, unknown> = Record<string, unknown>> {
+  $sort?: Partial<Record<keyof T & string, 1 | -1>>;
+  $skip?: number;
+  $limit?: number;
+  $count?: boolean;
+  $select?: SelectExpr<T>;
+  /** Fields to group by for aggregate queries. */
+  $groupBy?: (keyof T & string)[];
+  /** Post-aggregation filter. Operates on aggregate aliases and dimension fields. */
+  $having?: FilterExpr;
+  /** Relations to populate alongside the query. */
+  $with?: TypedWithRelation<Nav>[];
+  /** Pass-through for unknown $-prefixed keywords. */
+  [key: `$${string}`]: unknown;
+}
+/**
+ * Canonical query representation.
+ * When `name` is present this is a nested relation (sub-query inside `$with`).
+ * When absent it is the root query.
+ */
+interface Uniquery<T = Record<string, unknown>, Nav extends Record<string, unknown> = Record<string, unknown>> {
+  /** Relation name. Present only for nested `$with` sub-queries. */
+  name?: string;
+  filter?: FilterExpr<T>;
+  controls?: UniqueryControls<T, Nav>;
+  /** Pre-computed insights. */
+  insights?: UniqueryInsights;
+}
+/** Unwrap array types to get the element type for nav props. */
+type NavTarget<T> = T extends Array<infer U> ? U : T;
+/**
+ * A typed $with relation entry.
+ * When Nav is typed (from __navProps), name is constrained to known nav prop keys.
+ * Each entry gets its own filter/controls typed to the target entity.
+ * Falls back to untyped WithRelation when Nav has no known keys.
+ */
+type TypedWithRelation<Nav extends Record<string, unknown>> = [keyof Nav & string] extends [never] ? WithRelation | string : { [K in keyof Nav & string]: {
+  name: K;
+  filter?: FilterExpr<NavTarget<Nav[K]> extends {
+    __ownProps: infer F;
+  } ? F : Record<string, unknown>>;
+  controls?: UniqueryControls<NavTarget<Nav[K]> extends {
+    __ownProps: infer F;
+  } ? F : Record<string, unknown>, NavTarget<Nav[K]> extends {
+    __navProps: infer N extends Record<string, unknown>;
+  } ? N : Record<string, unknown>>;
+  insights?: UniqueryInsights;
+} }[keyof Nav & string] | (keyof Nav & string);
+/** Untyped $with relation — used when Nav generic is not provided. */
+type WithRelation = {
+  name: string;
+  filter?: FilterExpr;
+  controls?: UniqueryControls;
+  insights?: UniqueryInsights;
+};
+/**
+ * Insight operator includes comparison ops, control ops ($-prefixed),
+ * and aggregate function names (bare, e.g. 'sum', 'avg').
+ */
+type InsightOp = ComparisonOp | '$select' | '$order' | '$with' | '$groupBy' | '$having' | AggregateFn | (string & {});
+/** Map of field names to the set of operators used on that field. */
+type UniqueryInsights = Map<string, Set<InsightOp>>;
+/** Aggregate query controls. Separate from UniqueryControls: $groupBy is required, $with is forbidden. */
+interface AggregateControls<T = Record<string, unknown>, D extends keyof T & string = keyof T & string, M extends keyof T & string = keyof T & string> {
+  $groupBy: D[];
+  $select?: (D | AggregateExpr<AggregateFn, M | '*'>)[];
+  $having?: FilterExpr;
+  $sort?: Record<string, 1 | -1>;
+  $skip?: number;
+  $limit?: number;
+  $count?: boolean;
+  [key: `$${string}`]: unknown;
+}
+/** Aggregate query — no name (can't nest), no Nav (no $with). */
+interface AggregateQuery<T = Record<string, unknown>, D extends keyof T & string = keyof T & string, M extends keyof T & string = keyof T & string> {
+  filter?: FilterExpr<T>;
+  controls: AggregateControls<T, D, M>;
+  insights?: UniqueryInsights;
+}
+/** Resolve the output alias of an AggregateExpr. Uses $as if provided, otherwise generates {fn}_{field}. */
+//#endregion
+//#region ../../node_modules/.pnpm/@atscript+typescript@0.1.41_@atscript+core@0.1.41_@atscript+db@packages+db_@prostojs+lo_041ff52083ad05a1dfbd1c9f541c1d21/node_modules/@atscript/typescript/dist/utils.d.ts
+/** Top-level serialized annotated type. JSON-safe representation of a {@link TAtscriptAnnotatedType}. */
+interface TSerializedAnnotatedType extends TSerializedAnnotatedTypeInner {
+  /** Format version for forward compatibility */
+  $v: number;
+}
+/** Serialized annotated type node (used for nested types within the top-level). */
+interface TSerializedAnnotatedTypeInner {
+  type: TSerializedTypeDef;
+  metadata: Record<string, unknown>;
+  optional?: boolean;
+  id?: string;
+}
+interface TSerializedTypeFinal {
+  kind: '';
+  designType: string;
+  value?: string | number | boolean;
+  tags: string[];
+}
+interface TSerializedTypeObject {
+  kind: 'object';
+  props: Record<string, TSerializedAnnotatedTypeInner>;
+  propsPatterns: Array<{
+    pattern: {
+      source: string;
+      flags: string;
+    };
+    def: TSerializedAnnotatedTypeInner;
+  }>;
+  tags: string[];
+}
+interface TSerializedTypeArray {
+  kind: 'array';
+  of: TSerializedAnnotatedTypeInner;
+  tags: string[];
+}
+interface TSerializedTypeComplex {
+  kind: 'union' | 'intersection' | 'tuple';
+  items: TSerializedAnnotatedTypeInner[];
+  tags: string[];
+}
+interface TSerializedTypeRef {
+  kind: '$ref';
+  id: string;
+}
+type TSerializedTypeDef = TSerializedTypeFinal | TSerializedTypeObject | TSerializedTypeArray | TSerializedTypeComplex | TSerializedTypeRef;
+/** Context passed to {@link TSerializeOptions.processAnnotation} for each annotation entry. */
+//#endregion
+//#region src/types.d.ts
+/** Options for creating a Client instance. */
+interface ClientOptions {
+  /**
+   * Custom fetch implementation. Defaults to `globalThis.fetch`.
+   * Use this to inject auth headers, interceptors, or a custom HTTP client.
+   */
+  fetch?: typeof globalThis.fetch;
+  /**
+   * Default headers to include with every request.
+   * Can be a static object or an async factory (e.g. for refreshing auth tokens).
+   */
+  headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+  /**
+   * Base URL prefix. Prepended to the client path for full URL construction.
+   * @example "https://api.example.com"
+   */
+  baseUrl?: string;
+}
+/** Search index metadata from the server. */
+interface SearchIndexInfo {
+  name: string;
+  description?: string;
+  type?: "text" | "vector";
+}
+/** Relation summary in meta response. */
+interface RelationInfo {
+  name: string;
+  direction: "to" | "from" | "via";
+  isArray: boolean;
+}
+/** Per-field capability flags. */
+interface FieldMeta {
+  sortable: boolean;
+  filterable: boolean;
+}
+/** Enhanced meta response from the server. */
+interface MetaResponse {
+  searchable: boolean;
+  vectorSearchable: boolean;
+  searchIndexes: SearchIndexInfo[];
+  primaryKeys: string[];
+  readOnly: boolean;
+  relations: RelationInfo[];
+  fields: Record<string, FieldMeta>;
+  type: TSerializedAnnotatedType;
+}
+interface InsertResult {
+  insertedId: unknown;
+}
+interface InsertManyResult {
+  insertedCount: number;
+  insertedIds: unknown[];
+}
+interface UpdateResult {
+  matchedCount: number;
+  modifiedCount: number;
+}
+interface DeleteResult {
+  deletedCount: number;
+}
+/** Paginated response shape (matches moost-db /pages response). */
+interface PagesResponse<T> {
+  data: T[];
+  page: number;
+  itemsPerPage: number;
+  pages: number;
+  count: number;
+}
+/** Server error response shape (matches moost-db error transform). */
+interface ServerError {
+  message: string;
+  statusCode: number;
+  errors?: Array<{
+    path: string;
+    message: string;
+    details?: unknown[];
+  }>;
+}
+/** Extract the data type from an Atscript annotated type `T`. */
+type DataOf<T> = T extends {
+  type: {
+    __dataType?: infer D;
+  };
+} ? unknown extends D ? T extends (new (...a: any[]) => infer I) ? I : Record<string, unknown> : D & Record<string, unknown> : Record<string, unknown>;
+/** Extract own (non-nav) properties from an Atscript annotated type. */
+type OwnOf<T> = T extends {
+  __ownProps: infer O;
+} ? O : DataOf<T>;
+/** Extract nav properties from an Atscript annotated type. */
+type NavOf<T> = T extends {
+  __navProps: infer N extends Record<string, unknown>;
+} ? N : Record<string, never>;
+/** Extract primary key type from an Atscript annotated type. */
+type IdOf<T> = T extends {
+  __pk: infer PK;
+} ? PK : unknown;
+/**
+ * Shared interface for both server-side `AtscriptDbTable` and client-side `Client`.
+ * Enables SSR isomorphism: same code runs on server (direct DB) and browser (HTTP).
+ *
+ * ```typescript
+ * const users: DbInterface<typeof User> = isServer ? serverTable : httpClient
+ * await users.findMany({ filter: { active: true } })
+ * ```
+ */
+interface DbInterface<T = Record<string, unknown>> {
+  findOne(query: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T> | null>;
+  findMany(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T>[]>;
+  findById(id: IdOf<T>, query?: {
+    controls?: UniqueryControls<OwnOf<T>, NavOf<T>>;
+  }): Promise<DataOf<T> | null>;
+  count(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<number>;
+  search(text: string, query?: Uniquery<OwnOf<T>, NavOf<T>>, indexName?: string): Promise<DataOf<T>[]>;
+  aggregate(query: AggregateQuery): Promise<Record<string, unknown>[]>;
+  insertOne(data: Partial<DataOf<T>>): Promise<InsertResult>;
+  insertMany(data: Partial<DataOf<T>>[]): Promise<InsertManyResult>;
+  updateOne(data: Partial<DataOf<T>>): Promise<UpdateResult>;
+  bulkUpdate(data: Partial<DataOf<T>>[]): Promise<UpdateResult>;
+  replaceOne(data: DataOf<T>): Promise<UpdateResult>;
+  bulkReplace(data: DataOf<T>[]): Promise<UpdateResult>;
+  deleteOne(id: IdOf<T>): Promise<DeleteResult>;
+}
+//#endregion
+//#region src/client.d.ts
+/**
+ * Browser-compatible HTTP client for moost-db REST endpoints.
+ *
+ * Two usage modes (same class, different generic):
+ * ```typescript
+ * // Untyped — broad Record<string, unknown> typing
+ * const users = new Client('/db/tables/users')
+ *
+ * // Type-safe — Atscript type as generic parameter
+ * const users = new Client<typeof User>('/db/tables/users')
+ * ```
+ */
+declare class Client<T = Record<string, unknown>> implements DbInterface<T> {
+  private readonly _path;
+  private readonly _baseUrl;
+  private readonly _fetch;
+  private readonly _headers?;
+  private _metaPromise?;
+  constructor(path: string, opts?: ClientOptions);
+  findOne(query: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T> | null>;
+  findMany(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<DataOf<T>[]>;
+  findById(id: IdOf<T>, query?: {
+    controls?: UniqueryControls<OwnOf<T>, NavOf<T>>;
+  }): Promise<DataOf<T> | null>;
+  count(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<number>;
+  findManyWithCount(query: Uniquery<OwnOf<T>, NavOf<T>>): Promise<{
+    data: DataOf<T>[];
+    count: number;
+  }>;
+  pages(query?: Uniquery<OwnOf<T>, NavOf<T>>): Promise<PagesResponse<DataOf<T>>>;
+  search(text: string, query?: Uniquery<OwnOf<T>, NavOf<T>>, indexName?: string): Promise<DataOf<T>[]>;
+  aggregate(query: AggregateQuery): Promise<Record<string, unknown>[]>;
+  insertOne(data: Partial<DataOf<T>>): Promise<InsertResult>;
+  insertMany(data: Partial<DataOf<T>>[]): Promise<InsertManyResult>;
+  updateOne(data: Partial<DataOf<T>>): Promise<UpdateResult>;
+  bulkUpdate(data: Partial<DataOf<T>>[]): Promise<UpdateResult>;
+  replaceOne(data: DataOf<T>): Promise<UpdateResult>;
+  bulkReplace(data: DataOf<T>[]): Promise<UpdateResult>;
+  deleteOne(id: IdOf<T>): Promise<DeleteResult>;
+  meta(): Promise<MetaResponse>;
+  private _idToParams;
+  private _get;
+  private _resolveHeaders;
+  private _request;
+}
+//#endregion
+//#region src/client-error.d.ts
+/**
+ * Error thrown by `Client` when the server responds with a non-2xx status code.
+ * Captures the HTTP status and the structured error body from moost-db.
+ */
+declare class ClientError extends Error {
+  /** HTTP status code (e.g. 400, 404, 409, 500). */
+  readonly status: number;
+  /** Structured error response from the server. */
+  readonly body: ServerError;
+  name: string;
+  constructor(/** HTTP status code (e.g. 400, 404, 409, 500). */
+
+  status: number, /** Structured error response from the server. */
+
+  body: ServerError);
+  /** Shortcut to structured validation/DB errors from the server. */
+  get errors(): {
+    path: string;
+    message: string;
+    details?: unknown[];
+  }[];
+}
+//#endregion
+export { type AggregateQuery, Client, ClientError, type ClientOptions, type DataOf, type DbInterface, type DeleteResult, type FieldMeta, type FilterExpr, type IdOf, type InsertManyResult, type InsertResult, type MetaResponse, type NavOf, type OwnOf, type PagesResponse, type RelationInfo, type SearchIndexInfo, type ServerError, type TSerializedAnnotatedType, type TypedWithRelation, type Uniquery, type UniqueryControls, type UpdateResult };

package/dist/index.mjs

@@ -0,0 +1,195 @@
+import { buildUrl } from "@uniqu/url/builder";
+//#region src/client-error.ts
+/**
+* Error thrown by `Client` when the server responds with a non-2xx status code.
+* Captures the HTTP status and the structured error body from moost-db.
+*/
+var ClientError = class extends Error {
+	name = "ClientError";
+	constructor(status, body) {
+		super(body.message || `HTTP ${status}`);
+		this.status = status;
+		this.body = body;
+	}
+	/** Shortcut to structured validation/DB errors from the server. */
+	get errors() {
+		return this.body.errors ?? [];
+	}
+};
+//#endregion
+//#region src/client.ts
+/**
+* Browser-compatible HTTP client for moost-db REST endpoints.
+*
+* Two usage modes (same class, different generic):
+* ```typescript
+* // Untyped — broad Record<string, unknown> typing
+* const users = new Client('/db/tables/users')
+*
+* // Type-safe — Atscript type as generic parameter
+* const users = new Client<typeof User>('/db/tables/users')
+* ```
+*/
+var Client = class {
+	_path;
+	_baseUrl;
+	_fetch;
+	_headers;
+	_metaPromise;
+	constructor(path, opts) {
+		this._path = path.endsWith("/") ? path.slice(0, -1) : path;
+		this._baseUrl = opts?.baseUrl ?? "";
+		this._fetch = opts?.fetch ?? globalThis.fetch.bind(globalThis);
+		this._headers = opts?.headers;
+	}
+	async findOne(query) {
+		const controls = {
+			...query?.controls,
+			$limit: 1
+		};
+		return (await this._get("query", {
+			...query,
+			controls
+		}))[0] ?? null;
+	}
+	async findMany(query) {
+		return this._get("query", query);
+	}
+	async findById(id, query) {
+		if (id !== null && typeof id === "object") {
+			const params = this._idToParams(id);
+			if (query?.controls) {
+				const controlStr = buildUrl({ controls: query.controls });
+				if (controlStr) for (const [k, v] of new URLSearchParams(controlStr)) params.set(k, v);
+			}
+			const qs = params.toString();
+			try {
+				return await this._request("GET", `one${qs ? `?${qs}` : ""}`);
+			} catch (e) {
+				if (e instanceof ClientError && e.status === 404) return null;
+				throw e;
+			}
+		}
+		const controlStr = query?.controls ? buildUrl({ controls: query.controls }) : "";
+		try {
+			return await this._request("GET", `one/${encodeURIComponent(String(id))}${controlStr ? `?${controlStr}` : ""}`);
+		} catch (e) {
+			if (e instanceof ClientError && e.status === 404) return null;
+			throw e;
+		}
+	}
+	async count(query) {
+		const controls = {
+			...query?.controls,
+			$count: true
+		};
+		return this._get("query", {
+			...query,
+			controls
+		});
+	}
+	async findManyWithCount(query) {
+		const controls = query?.controls ?? {};
+		const limit = controls.$limit || 1e3;
+		const skip = controls.$skip || 0;
+		const page = Math.floor(skip / limit) + 1;
+		const result = await this._get("pages", {
+			...query,
+			controls: {
+				...controls,
+				$page: page,
+				$size: limit
+			}
+		});
+		return {
+			data: result.data,
+			count: result.count
+		};
+	}
+	async pages(query) {
+		return this._get("pages", query);
+	}
+	async search(text, query, indexName) {
+		const controls = {
+			...query?.controls,
+			$search: text
+		};
+		if (indexName) controls.$index = indexName;
+		return this._get("query", {
+			...query,
+			controls
+		});
+	}
+	async aggregate(query) {
+		return this._get("query", query);
+	}
+	async insertOne(data) {
+		return this._request("POST", "", data);
+	}
+	async insertMany(data) {
+		return this._request("POST", "", data);
+	}
+	async updateOne(data) {
+		return this._request("PATCH", "", data);
+	}
+	async bulkUpdate(data) {
+		return this._request("PATCH", "", data);
+	}
+	async replaceOne(data) {
+		return this._request("PUT", "", data);
+	}
+	async bulkReplace(data) {
+		return this._request("PUT", "", data);
+	}
+	async deleteOne(id) {
+		if (id !== null && typeof id === "object") return this._request("DELETE", `?${this._idToParams(id).toString()}`);
+		return this._request("DELETE", encodeURIComponent(String(id)));
+	}
+	async meta() {
+		if (!this._metaPromise) this._metaPromise = this._request("GET", "meta");
+		return this._metaPromise;
+	}
+	_idToParams(id) {
+		const params = new URLSearchParams();
+		for (const [k, v] of Object.entries(id)) params.set(k, String(v));
+		return params;
+	}
+	async _get(endpoint, query) {
+		const qs = query ? buildUrl(query) : "";
+		return this._request("GET", `${endpoint}${qs ? `?${qs}` : ""}`);
+	}
+	async _resolveHeaders() {
+		if (!this._headers) return {};
+		if (typeof this._headers === "function") return await this._headers();
+		return this._headers;
+	}
+	async _request(method, endpoint, body) {
+		const sep = endpoint && !endpoint.startsWith("?") ? "/" : "";
+		const url = `${this._baseUrl}${this._path}${sep}${endpoint}`;
+		const headers = { ...await this._resolveHeaders() };
+		const init = {
+			method,
+			headers
+		};
+		if (body !== void 0) {
+			headers["Content-Type"] = "application/json";
+			init.body = JSON.stringify(body);
+		}
+		const res = await this._fetch(url, init);
+		if (!res.ok) {
+			let errorBody;
+			try {
+				errorBody = await res.json();
+			} catch {
+				errorBody = {
+					message: res.statusText,
+					statusCode: res.status
+				};
+			}
+			throw new ClientError(res.status, errorBody);
+		}
+		return res.json();
+	}
+};
+//#endregion
+export { Client, ClientError };

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@atscript/db-client",
+  "version": "0.1.43",
+  "description": "Browser-compatible HTTP client for @atscript/moost-db REST endpoints.",
+  "keywords": [
+    "atscript",
+    "client",
+    "database",
+    "http",
+    "rest"
+  ],
+  "homepage": "https://github.com/moostjs/atscript-db/tree/main/packages/db-client#readme",
+  "bugs": {
+    "url": "https://github.com/moostjs/atscript-db/issues"
+  },
+  "license": "MIT",
+  "author": "Artem Maltsev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/atscript-db.git",
+    "directory": "packages/db-client"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@uniqu/url": "^0.1.2"
+  },
+  "devDependencies": {
+    "@atscript/typescript": "^0.1.41",
+    "@uniqu/core": "^0.1.2"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}