@atscript/db-client 0.1.43 → 0.1.45

package/dist/index.mjs

@@ -19,15 +19,24 @@ var ClientError = class extends Error {
 //#endregion
 //#region src/client.ts
 /**
-* Browser-compatible HTTP client for moost-db REST endpoints.
+* 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')
+* Each method maps 1:1 to a controller endpoint:
+* - `query()` → `GET /query`
+* - `count()` → `GET /query` with `$count`
+* - `aggregate()` → `GET /query` with `$groupBy`
+* - `pages()` → `GET /pages`
+* - `one()`   → `GET /one/:id` or `GET /one?compositeKeys`
+* - `insert()`  → `POST /`
+* - `update()`  → `PATCH /`
+* - `replace()` → `PUT /`
+* - `remove()`  → `DELETE /:id` or `DELETE /?compositeKeys`
+* - `meta()`  → `GET /meta`
 *
-* // Type-safe — Atscript type as generic parameter
-* const users = new Client<typeof User>('/db/tables/users')
+* ```typescript
+* const users = new Client<typeof User>('/api/users')
+* const all = await users.query()
+* const page = await users.pages({ filter: { active: true } }, 1, 20)
 * ```
 */
 var Client = class {
@@ -36,124 +45,127 @@ var Client = class {
 	_fetch;
 	_headers;
 	_metaPromise;
+	_validatorPromise;
 	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) {
+	/**
+	* `GET /query` — query records with typed filter, sort, select, and relations.
+	*/
+	async query(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;
-		}
-	}
+	/**
+	* `GET /query` with `$count: true` — returns record count.
+	*/
 	async count(query) {
-		const controls = {
-			...query?.controls,
-			$count: true
-		};
 		return this._get("query", {
 			...query,
-			controls
+			controls: { $count: true }
 		});
 	}
-	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", {
+	/**
+	* `GET /query` with `$groupBy` — aggregate query with typed dimension/measure fields.
+	*/
+	async aggregate(query) {
+		return this._get("query", query);
+	}
+	/**
+	* `GET /pages` — paginated query with typed filter and relations.
+	*/
+	async pages(query, page = 1, size = 10) {
+		return this._get("pages", {
 			...query,
 			controls: {
-				...controls,
+				...query?.controls,
 				$page: page,
-				$size: limit
+				$size: size
 			}
 		});
-		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);
+	/**
+	* `GET /one/:id` or `GET /one?k1=v1&k2=v2` — single record by primary key.
+	*
+	* Returns `null` on 404.
+	*/
+	async one(id, query) {
+		const controlStr = query?.controls ? buildUrl({ controls: query.controls }) : "";
+		if (id !== null && typeof id === "object") {
+			const params = this._idToParams(id);
+			if (controlStr) for (const [k, v] of new URLSearchParams(controlStr)) params.set(k, v);
+			const qs = params.toString();
+			return this._getOrNull(`one${qs ? `?${qs}` : ""}`);
+		}
+		return this._getOrNull(`one/${encodeURIComponent(String(id))}${controlStr ? `?${controlStr}` : ""}`);
 	}
-	async insertMany(data) {
+	async insert(data) {
+		await this._validateData(data, "insert");
 		return this._request("POST", "", data);
 	}
-	async updateOne(data) {
-		return this._request("PATCH", "", data);
-	}
-	async bulkUpdate(data) {
+	/**
+	* `PATCH /` — partial update one or many records by primary key.
+	*/
+	async update(data) {
+		await this._validateData(data, "patch");
 		return this._request("PATCH", "", data);
 	}
-	async replaceOne(data) {
+	/**
+	* `PUT /` — full replace one or many records by primary key.
+	*/
+	async replace(data) {
+		await this._validateData(data, "replace");
 		return this._request("PUT", "", data);
 	}
-	async bulkReplace(data) {
-		return this._request("PUT", "", data);
-	}
-	async deleteOne(id) {
+	/**
+	* `DELETE /:id` or `DELETE /?k1=v1&k2=v2` — remove a record by primary key.
+	*/
+	async remove(id) {
 		if (id !== null && typeof id === "object") return this._request("DELETE", `?${this._idToParams(id).toString()}`);
 		return this._request("DELETE", encodeURIComponent(String(id)));
 	}
+	/**
+	* `GET /meta` — table/view metadata (cached after first call).
+	*/
 	async meta() {
-		if (!this._metaPromise) this._metaPromise = this._request("GET", "meta");
+		if (!this._metaPromise) this._metaPromise = this._request("GET", "meta").catch((err) => {
+			this._metaPromise = void 0;
+			throw err;
+		});
 		return this._metaPromise;
 	}
+	/**
+	* Returns a lazily-initialized {@link ClientValidator} backed by the `/meta` type.
+	* Useful for accessing `flatMap` and `navFields` (e.g. for form generation).
+	*/
+	getValidator() {
+		return this._getValidator();
+	}
+	async _validateData(data, mode) {
+		(await this._getValidator()).validate(data, mode);
+	}
+	_getValidator() {
+		if (!this._validatorPromise) this._validatorPromise = Promise.all([this.meta(), import("./validator.mjs")]).then(([m, { createClientValidator }]) => createClientValidator(m)).catch((err) => {
+			this._validatorPromise = void 0;
+			throw err;
+		});
+		return this._validatorPromise;
+	}
 	_idToParams(id) {
 		const params = new URLSearchParams();
 		for (const [k, v] of Object.entries(id)) params.set(k, String(v));
 		return params;
 	}
+	async _getOrNull(endpoint) {
+		try {
+			return await this._request("GET", endpoint);
+		} catch (e) {
+			if (e instanceof ClientError && e.status === 404) return null;
+			throw e;
+		}
+	}
 	async _get(endpoint, query) {
 		const qs = query ? buildUrl(query) : "";
 		return this._request("GET", `${endpoint}${qs ? `?${qs}` : ""}`);

package/dist/validator-Baaf7PPf.d.cts

@@ -0,0 +1,137 @@
+import { AggregateQuery as AggregateQuery$1, AggregateResult as AggregateResult$1, FilterExpr, TypedWithRelation, Uniquery as Uniquery$1, UniqueryControls as UniqueryControls$1 } from "@uniqu/core";
+import { TDbDeleteResult as TDbDeleteResult$1, TDbInsertManyResult as TDbInsertManyResult$1, TDbInsertResult as TDbInsertResult$1, TDbUpdateResult as TDbUpdateResult$1 } from "@atscript/db";
+import { TAtscriptAnnotatedType, TAtscriptTypeObject, TSerializedAnnotatedType } from "@atscript/typescript/utils";
+import { DbValidationContext, ValidatorMode, ValidatorMode as ValidatorMode$1 } from "@atscript/db/validator";
+
+//#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 (`GET /meta`). */
+interface MetaResponse {
+  searchable: boolean;
+  vectorSearchable: boolean;
+  searchIndexes: SearchIndexInfo[];
+  primaryKeys: string[];
+  readOnly: boolean;
+  relations: RelationInfo[];
+  fields: Record<string, FieldMeta>;
+  type: TSerializedAnnotatedType;
+}
+/** Paginated response shape from `GET /pages`. */
+interface PageResult<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;
+//#endregion
+//#region src/validator.d.ts
+/**
+ * Client-side validator backed by an Atscript type from the `/meta` endpoint.
+ *
+ * Caches validators per mode. Lazily initializes from a meta response promise.
+ */
+declare class ClientValidator {
+  private _type;
+  private _validators;
+  /** Flat map of dotted field paths to their annotated types. */
+  readonly flatMap: Map<string, TAtscriptAnnotatedType>;
+  /** Set of field paths that are navigation relations (TO/FROM/VIA). */
+  readonly navFields: ReadonlySet<string>;
+  constructor(type: TAtscriptAnnotatedType<TAtscriptTypeObject>);
+  /**
+   * Validate data for a given write mode.
+   * Throws `ClientValidationError` if validation fails.
+   */
+  validate(data: unknown, mode: ValidatorMode): void;
+  private _getValidator;
+}
+/**
+ * Structured validation error thrown before HTTP requests when client-side
+ * validation fails.
+ */
+declare class ClientValidationError extends Error {
+  readonly errors: Array<{
+    path: string;
+    message: string;
+  }>;
+  constructor(errors: Array<{
+    path: string;
+    message: string;
+  }>);
+}
+/**
+ * Create a {@link ClientValidator} from a meta response (or promise).
+ *
+ * @example
+ * ```typescript
+ * const client = new Client<typeof User>('/db/tables/users')
+ * const validator = createClientValidator(await client.meta())
+ * validator.validate({ name: 'foo' }, 'insert')
+ * ```
+ */
+declare function createClientValidator(meta: MetaResponse): ClientValidator;
+//#endregion
+export { TDbUpdateResult$1 as C, UniqueryControls$1 as E, TDbInsertResult$1 as S, Uniquery$1 as T, RelationInfo as _, createClientValidator as a, TDbDeleteResult$1 as b, ClientOptions as c, FilterExpr as d, IdOf as f, PageResult as g, OwnOf as h, ValidatorMode$1 as i, DataOf as l, NavOf as m, ClientValidator as n, AggregateQuery$1 as o, MetaResponse as p, DbValidationContext as r, AggregateResult$1 as s, ClientValidationError as t, FieldMeta as u, SearchIndexInfo as v, TypedWithRelation as w, TDbInsertManyResult$1 as x, ServerError as y };

package/dist/validator-D0lqruKm.d.mts

@@ -0,0 +1,137 @@
+import { TAtscriptAnnotatedType, TAtscriptTypeObject, TSerializedAnnotatedType } from "@atscript/typescript/utils";
+import { DbValidationContext, ValidatorMode, ValidatorMode as ValidatorMode$1 } from "@atscript/db/validator";
+import { AggregateQuery as AggregateQuery$1, AggregateResult as AggregateResult$1, FilterExpr, TypedWithRelation, Uniquery as Uniquery$1, UniqueryControls as UniqueryControls$1 } from "@uniqu/core";
+import { TDbDeleteResult as TDbDeleteResult$1, TDbInsertManyResult as TDbInsertManyResult$1, TDbInsertResult as TDbInsertResult$1, TDbUpdateResult as TDbUpdateResult$1 } from "@atscript/db";
+
+//#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 (`GET /meta`). */
+interface MetaResponse {
+  searchable: boolean;
+  vectorSearchable: boolean;
+  searchIndexes: SearchIndexInfo[];
+  primaryKeys: string[];
+  readOnly: boolean;
+  relations: RelationInfo[];
+  fields: Record<string, FieldMeta>;
+  type: TSerializedAnnotatedType;
+}
+/** Paginated response shape from `GET /pages`. */
+interface PageResult<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;
+//#endregion
+//#region src/validator.d.ts
+/**
+ * Client-side validator backed by an Atscript type from the `/meta` endpoint.
+ *
+ * Caches validators per mode. Lazily initializes from a meta response promise.
+ */
+declare class ClientValidator {
+  private _type;
+  private _validators;
+  /** Flat map of dotted field paths to their annotated types. */
+  readonly flatMap: Map<string, TAtscriptAnnotatedType>;
+  /** Set of field paths that are navigation relations (TO/FROM/VIA). */
+  readonly navFields: ReadonlySet<string>;
+  constructor(type: TAtscriptAnnotatedType<TAtscriptTypeObject>);
+  /**
+   * Validate data for a given write mode.
+   * Throws `ClientValidationError` if validation fails.
+   */
+  validate(data: unknown, mode: ValidatorMode): void;
+  private _getValidator;
+}
+/**
+ * Structured validation error thrown before HTTP requests when client-side
+ * validation fails.
+ */
+declare class ClientValidationError extends Error {
+  readonly errors: Array<{
+    path: string;
+    message: string;
+  }>;
+  constructor(errors: Array<{
+    path: string;
+    message: string;
+  }>);
+}
+/**
+ * Create a {@link ClientValidator} from a meta response (or promise).
+ *
+ * @example
+ * ```typescript
+ * const client = new Client<typeof User>('/db/tables/users')
+ * const validator = createClientValidator(await client.meta())
+ * validator.validate({ name: 'foo' }, 'insert')
+ * ```
+ */
+declare function createClientValidator(meta: MetaResponse): ClientValidator;
+//#endregion
+export { TDbUpdateResult$1 as C, UniqueryControls$1 as E, TDbInsertResult$1 as S, Uniquery$1 as T, RelationInfo as _, createClientValidator as a, TDbDeleteResult$1 as b, ClientOptions as c, FilterExpr as d, IdOf as f, PageResult as g, OwnOf as h, ValidatorMode$1 as i, DataOf as l, NavOf as m, ClientValidator as n, AggregateQuery$1 as o, MetaResponse as p, DbValidationContext as r, AggregateResult$1 as s, ClientValidationError as t, FieldMeta as u, SearchIndexInfo as v, TypedWithRelation as w, TDbInsertManyResult$1 as x, ServerError as y };

package/dist/validator.cjs

@@ -0,0 +1,82 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _atscript_typescript_utils = require("@atscript/typescript/utils");
+let _atscript_db_validator = require("@atscript/db/validator");
+//#region src/validator.ts
+/**
+* Client-side validator backed by an Atscript type from the `/meta` endpoint.
+*
+* Caches validators per mode. Lazily initializes from a meta response promise.
+*/
+var ClientValidator = class {
+	_type;
+	_validators = /* @__PURE__ */ new Map();
+	/** Flat map of dotted field paths to their annotated types. */
+	flatMap;
+	/** Set of field paths that are navigation relations (TO/FROM/VIA). */
+	navFields;
+	constructor(type) {
+		this._type = type;
+		const ctx = (0, _atscript_db_validator.buildValidationContext)(type);
+		this.flatMap = ctx.flatMap;
+		this.navFields = ctx.navFields;
+	}
+	/**
+	* Validate data for a given write mode.
+	* Throws `ClientValidationError` if validation fails.
+	*/
+	validate(data, mode) {
+		const isArray = Array.isArray(data);
+		const items = isArray ? data : [data];
+		const validator = this._getValidator(mode);
+		const ctx = {
+			mode,
+			flatMap: this.flatMap,
+			navFields: this.navFields
+		};
+		for (let i = 0; i < items.length; i++) if (!validator.validate(items[i], true, ctx)) {
+			const prefix = isArray ? `[${i}]` : "";
+			throw new ClientValidationError(validator.errors.map((e) => ({
+				path: prefix ? e.path ? `${prefix}.${e.path}` : prefix : e.path,
+				message: e.message
+			})));
+		}
+	}
+	_getValidator(mode) {
+		let v = this._validators.get(mode);
+		if (!v) {
+			v = (0, _atscript_db_validator.buildDbValidator)(this._type, mode);
+			this._validators.set(mode, v);
+		}
+		return v;
+	}
+};
+/**
+* Structured validation error thrown before HTTP requests when client-side
+* validation fails.
+*/
+var ClientValidationError = class extends Error {
+	errors;
+	constructor(errors) {
+		const msg = errors.length === 1 ? errors[0].message : `Validation failed with ${errors.length} errors`;
+		super(msg);
+		this.name = "ClientValidationError";
+		this.errors = errors;
+	}
+};
+/**
+* Create a {@link ClientValidator} from a meta response (or promise).
+*
+* @example
+* ```typescript
+* const client = new Client<typeof User>('/db/tables/users')
+* const validator = createClientValidator(await client.meta())
+* validator.validate({ name: 'foo' }, 'insert')
+* ```
+*/
+function createClientValidator(meta) {
+	return new ClientValidator((0, _atscript_typescript_utils.deserializeAnnotatedType)(meta.type));
+}
+//#endregion
+exports.ClientValidationError = ClientValidationError;
+exports.ClientValidator = ClientValidator;
+exports.createClientValidator = createClientValidator;

package/dist/validator.d.cts

@@ -0,0 +1,2 @@
+import { a as createClientValidator, i as ValidatorMode, n as ClientValidator, r as DbValidationContext, t as ClientValidationError } from "./validator-Baaf7PPf.cjs";
+export { ClientValidationError, ClientValidator, DbValidationContext, ValidatorMode, createClientValidator };

package/dist/validator.d.mts

@@ -0,0 +1,2 @@
+import { a as createClientValidator, i as ValidatorMode, n as ClientValidator, r as DbValidationContext, t as ClientValidationError } from "./validator-D0lqruKm.mjs";
+export { ClientValidationError, ClientValidator, DbValidationContext, ValidatorMode, createClientValidator };

package/dist/validator.mjs

@@ -0,0 +1,79 @@
+import { deserializeAnnotatedType } from "@atscript/typescript/utils";
+import { buildDbValidator, buildValidationContext } from "@atscript/db/validator";
+//#region src/validator.ts
+/**
+* Client-side validator backed by an Atscript type from the `/meta` endpoint.
+*
+* Caches validators per mode. Lazily initializes from a meta response promise.
+*/
+var ClientValidator = class {
+	_type;
+	_validators = /* @__PURE__ */ new Map();
+	/** Flat map of dotted field paths to their annotated types. */
+	flatMap;
+	/** Set of field paths that are navigation relations (TO/FROM/VIA). */
+	navFields;
+	constructor(type) {
+		this._type = type;
+		const ctx = buildValidationContext(type);
+		this.flatMap = ctx.flatMap;
+		this.navFields = ctx.navFields;
+	}
+	/**
+	* Validate data for a given write mode.
+	* Throws `ClientValidationError` if validation fails.
+	*/
+	validate(data, mode) {
+		const isArray = Array.isArray(data);
+		const items = isArray ? data : [data];
+		const validator = this._getValidator(mode);
+		const ctx = {
+			mode,
+			flatMap: this.flatMap,
+			navFields: this.navFields
+		};
+		for (let i = 0; i < items.length; i++) if (!validator.validate(items[i], true, ctx)) {
+			const prefix = isArray ? `[${i}]` : "";
+			throw new ClientValidationError(validator.errors.map((e) => ({
+				path: prefix ? e.path ? `${prefix}.${e.path}` : prefix : e.path,
+				message: e.message
+			})));
+		}
+	}
+	_getValidator(mode) {
+		let v = this._validators.get(mode);
+		if (!v) {
+			v = buildDbValidator(this._type, mode);
+			this._validators.set(mode, v);
+		}
+		return v;
+	}
+};
+/**
+* Structured validation error thrown before HTTP requests when client-side
+* validation fails.
+*/
+var ClientValidationError = class extends Error {
+	errors;
+	constructor(errors) {
+		const msg = errors.length === 1 ? errors[0].message : `Validation failed with ${errors.length} errors`;
+		super(msg);
+		this.name = "ClientValidationError";
+		this.errors = errors;
+	}
+};
+/**
+* Create a {@link ClientValidator} from a meta response (or promise).
+*
+* @example
+* ```typescript
+* const client = new Client<typeof User>('/db/tables/users')
+* const validator = createClientValidator(await client.meta())
+* validator.validate({ name: 'foo' }, 'insert')
+* ```
+*/
+function createClientValidator(meta) {
+	return new ClientValidator(deserializeAnnotatedType(meta.type));
+}
+//#endregion
+export { ClientValidationError, ClientValidator, createClientValidator };