@uql/core 1.0.12 → 3.0.0

package/dist/README.md

@@ -0,0 +1,413 @@
+<!-- ![code](/assets/code.webp 'code') -->
+
+[![uql maku](assets/logo.svg)](https://uql.app)
+
+[![tests](https://github.com/rogerpadilla/uql/actions/workflows/tests.yml/badge.svg)](https://github.com/rogerpadilla/uql) [![coverage status](https://coveralls.io/repos/rogerpadilla/uql/badge.svg?branch=main)](https://coveralls.io/r/rogerpadilla/uql?branch=main) [![license](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/rogerpadilla/uql/blob/main/LICENSE) [![npm version](https://img.shields.io/npm/v/@uql/core.svg)](https://www.npmjs.com/package/@uql/core)
+
+[uql](https://uql.app) is the [smartest ORM](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) for TypeScript, it is designed to be fast, safe, and easy to integrate into any application.
+
+It can run in Node.js, Browser, React Native, Expo, Electron, Deno, Bun, and many more!
+
+Uses a consistent API for distinct databases, including PostgreSQL, MySQL, MariaDB, and SQLite (inspired by MongoDB glorious syntax).
+
+&nbsp;
+
+```ts
+const companyUsers = await userRepository.findMany({
+  $select: { email: true, profile: { $select: { picture: true } } },
+  $where: { email: { $endsWith: '@domain.com' } },
+  $sort: { createdAt: 'desc' },
+  $limit: 100,
+});
+```
+
+&nbsp;
+
+## Why uql?
+
+See [this article](https://medium.com/@rogerpadillac/in-search-of-the-perfect-orm-e01fcc9bce3d) in medium.com.
+
+&nbsp;
+
+## Features
+
+- **Type-safe and Context-aware queries**: Squeeze the power of `TypeScript` for auto-completion and validation of operators at any depth, [including relations and their fields](https://www.uql.app/docs/querying-relations).
+- **Context-Object SQL Generation**: Uses a sophisticated `QueryContext` pattern to ensure perfectly indexed placeholders ($1, $2, etc.) and robust SQL fragment management, even in the most complex sub-queries.
+- **Unified API across Databases**: Write once, run anywhere. Seamlessly switch between `PostgreSQL`, `MySQL`, `MariaDB`, `SQLite`, and even `MongoDB`.
+- **Serializable JSON Syntax**: Queries can be expressed as `100%` valid `JSON`, allowing them to be easily transported from frontend to backend.
+- **Naming Strategies**: Effortlessly translate between TypeScript `CamelCase` and database `snake_case` (or any custom format) with a pluggable system.
+- **Built-in Serialization**: A centralized task queue and `@Serialized()` decorator ensure database operations are thread-safe and race-condition free by default.
+- **Database Migrations**: Integrated migration system for version-controlled schema management and auto-generation from entities.
+- **High Performance**: Optimized "Sticky Connections" and human-readable, minimal SQL generation.
+- **Modern Architecture**: Pure `ESM` support, designed for `Node.js`, `Bun`, `Deno`, and even mobile/browser environments.
+- **Rich Feature Set**: [Soft-delete](https://uql.app/docs/entities-soft-delete), [virtual fields](https://uql.app/docs/entities-virtual-fields), [repositories](https://uql.app/docs/querying-repository), and automatic handling of `JSON`, `JSONB`, and `Vector` types.
+
+&nbsp;
+
+## 1. Install
+
+1. Install the core package:
+
+   ```sh
+   npm install @uql/core
+   # or
+   bun add @uql/core
+   ```
+
+2. Install one of the specific adapters for your database:
+
+| Database     | Driver           | UQL Adapter    |
+| ------------ | ---------------- | ---------------- |
+| `PostgreSQL` | `pg`             | `uql-postgres` |
+| `SQLite`     | `better-sqlite3` | `uql-sqlite`   |
+| `MariaDB`    | `mariadb`        | `uql-maria`    |
+| `MySQL`      | `mysql2`         | `uql-mysql`    |
+
+&nbsp;
+
+For example, for `Postgres` install the `pg` driver:
+
+```sh
+npm install pg
+# or
+bun add pg
+```
+
+3. Additionally, your `tsconfig.json` may need the following flags:
+
+   ```json
+   "target": "es2022",
+   "experimentalDecorators": true,
+   "emitDecoratorMetadata": true
+   ```
+
+&nbsp;
+
+> **Note**: UQL provides first-class support for **Bun**. It is recommended to use Bun for a significantly faster developer experience.
+
+---
+
+&nbsp;
+
+## 2. Define the entities
+
+Annotate your classes with decorators from `uql/entity`. UQL supports detailed schema metadata for precise DDL generation.
+
+```ts
+import { Entity, Id, Field, OneToOne, OneToMany, ManyToOne, ManyToMany } from '@uql/core/entity';
+import type { Relation } from '@uql/core/type';
+
+@Entity()
+export class User {
+  @Id()
+  id?: string;
+
+  @Field({ length: 100, index: true })
+  name?: string;
+
+  @Field({ unique: true, comment: 'User login email' })
+  email?: string;
+
+  @OneToOne({ entity: () => Profile, mappedBy: 'user', cascade: true })
+  profile?: Relation<Profile>; // Relation<T> handles circular dependencies
+
+  @OneToMany({ entity: () => Post, mappedBy: 'author' })
+  posts?: Relation<Post>[];
+}
+
+@Entity()
+export class Profile {
+  @Id()
+  id?: string;
+
+  @Field()
+  bio?: string;
+
+  @Field({ reference: () => User })
+  userId?: string;
+
+  @OneToOne({ entity: () => User })
+  user?: User;
+}
+
+@Entity()
+export class Post {
+  @Id()
+  id?: number;
+
+  @Field()
+  title?: string;
+
+  @Field({ reference: () => User })
+  authorId?: string;
+
+  @ManyToOne({ entity: () => User })
+  author?: User;
+
+  @ManyToMany({ entity: () => Tag, through: () => PostTag })
+  tags?: Tag[];
+}
+
+@Entity()
+export class Tag {
+  @Id()
+  id?: string;
+
+  @Field()
+  name?: string;
+}
+
+@Entity()
+export class PostTag {
+  @Id()
+  id?: string;
+
+  @Field({ reference: () => Post })
+  postId?: number;
+
+  @Field({ reference: () => Tag })
+  tagId?: string;
+}
+```
+
+&nbsp;
+
+## 3. Setup a querier-pool
+
+A querier-pool can be set in any of the bootstrap files of your app (e.g. in the `server.ts`).
+
+```ts
+// file: ./shared/orm.ts
+import { SnakeCaseNamingStrategy } from '@uql/core';
+import { PgQuerierPool } from 'uql-postgres';
+
+export const querierPool = new PgQuerierPool(
+  {
+    host: 'localhost',
+    user: 'theUser',
+    password: 'thePassword',
+    database: 'theDatabase',
+    min: 1,
+    max: 10,
+  },
+  // Optional extra options.
+  {
+    // Optional, any custom logger function can be passed here (optional).
+    logger: console.debug,
+    // Automatically translate between TypeScript camelCase and database snake_case.
+    // This affects both queries and schema generation.
+    namingStrategy: new SnakeCaseNamingStrategy()
+  },
+);
+```
+
+&nbsp;
+
+## 4. Manipulate the data
+
+UQL provides multiple ways to interact with your data, from low-level `Queriers` to high-level `Repositories`.
+
+### Using Repositories (Recommended)
+
+Repositories provide a clean, Data-Mapper style interface for your entities.
+
+```ts
+import { GenericRepository } from '@uql/core/repository';
+import { User } from './shared/models/index.js';
+import { querierPool } from './shared/orm.js';
+
+// Get a querier from the pool
+const querier = await querierPool.getQuerier();
+
+try {
+  const userRepository = new GenericRepository(User, querier);
+
+  // Advanced querying with relations and virtual fields
+  const users = await userRepository.findMany({
+    $select: {
+      id: true,
+      name: true,
+      profile: ['picture'], // Select specific fields from a 1-1 relation
+      tagsCount: true       // Virtual field (calculated at runtime)
+    },
+    $where: {
+      email: { $iincludes: '@uql/core' }, // Case-insensitive search
+      status: 'active'
+    },
+    $sort: { createdAt: -1 },
+    $limit: 50
+  });
+} finally {
+  // Always release the querier to the pool
+  await querier.release();
+}
+```
+
+### Advanced: Deep Selection & Filtering
+
+UQL's query syntax is context-aware. When you query a relation, the available fields and operators are automatically suggested and validated based on that related entity.
+
+```ts
+import { GenericRepository } from '@uql/core/repository';
+import { User } from './shared/models/index.js';
+import { querierPool } from './shared/orm.js';
+
+const authorsWithPopularPosts = await querierPool.transaction(async (querier) => {
+  const userRepository = new GenericRepository(User, querier);
+
+  return userRepository.findMany({
+    $select: {
+      id: true,
+      name: true,
+      profile: {
+        $select: ['bio'],
+        // Filter related record and enforce INNER JOIN
+        $where: { bio: { $ne: null } },
+        $required: true
+      },
+      posts: {
+        $select: ['title', 'createdAt'],
+        // Filter the related collection directly
+        $where: { title: { $iincludes: 'typescript' } },
+        $sort: { createdAt: -1 },
+        $limit: 5
+      }
+    },
+    $where: {
+      name: { $istartsWith: 'a' }
+    }
+  });
+});
+```
+
+### Advanced: Virtual Fields & Raw SQL
+
+Define complex logic directly in your entities using `raw` functions from `uql/util`. These are highly efficient as they are resolved during SQL generation.
+
+```ts
+import { Entity, Id, Field } from '@uql/core/entity';
+import { raw } from '@uql/core/util';
+import { ItemTag } from './shared/models/index.js';
+
+@Entity()
+export class Item {
+  @Id()
+  id: number;
+
+  @Field()
+  name: string;
+
+  @Field({
+    virtual: raw(({ ctx, dialect, escapedPrefix }) => {
+      ctx.append('(');
+      dialect.count(ctx, ItemTag, {
+        $where: {
+          itemId: raw(({ ctx }) => ctx.append(`${escapedPrefix}.id`))
+        }
+      }, { autoPrefix: true });
+      ctx.append(')');
+    })
+  })
+  tagsCount?: number;
+}
+```
+
+### Thread-Safe Transactions
+
+UQL ensures your operations are serialized and thread-safe.
+
+```ts
+import { User, Profile } from './shared/models/index.js';
+import { querierPool } from './shared/orm.js';
+
+const result = await querierPool.transaction(async (querier) => {
+  const user = await querier.findOne(User, { $where: { email: '...' } });
+  const profileId = await querier.insertOne(Profile, { userId: user.id, ... });
+  return { userId: user.id, profileId };
+});
+// Connection is automatically released after transaction
+```
+
+&nbsp;
+
+## 5. Migrations & Synchronization
+
+UQL includes a robust migration system and an "Entity-First" synchronization engine built directly into the core.
+
+### 1. Create Configuration
+
+Create a `uql.config.ts` file in your project root:
+
+```typescript
+import { PgQuerierPool } from 'uql-postgres';
+import { User, Post } from './src/entities/index.js';
+
+export default {
+  querierPool: new PgQuerierPool({ /* config */ }),
+  dialect: 'postgres',
+  entities: [User, Post],
+  migrationsPath: './migrations',
+};
+```
+
+### 2. Manage via CLI
+
+UQL provides a dedicated CLI tool for migrations.
+
+```bash
+# Generate a migration by comparing entities vs database
+npx uql-migrate generate:entities initial_schema
+# or
+bunx uql-migrate generate:entities initial_schema
+
+# Run pending migrations
+npx uql-migrate up
+# or
+bunx uql-migrate up
+
+# Rollback the last migration
+npx uql-migrate down
+# or
+bunx uql-migrate down
+
+# Check status
+npx uql-migrate status
+# or
+bunx uql-migrate status
+```
+
+### 3. Entity-First Synchronization (Development)
+
+In development, you can use `autoSync` to automatically keep your database in sync with your entities without manual migrations. It is **safe by default**, meaning it only adds missing tables and columns.
+
+```ts
+import { Migrator } from '@uql/core/migrate';
+import { querierPool } from './shared/orm.js';
+
+const migrator = new Migrator(querierPool);
+await migrator.autoSync({ logging: true });
+```
+
+Check out the full [documentation](https://uql.app/docs/migrations) for detailed CLI commands and advanced usage.
+
+&nbsp;
+
+Check out the full documentation at [uql.app](https://uql.app) for details on:
+- [Complex Logical Operators](https://uql.app/docs/querying-logical-operators)
+- [Relationship Mapping (1-1, 1-M, M-M)](https://uql.app/docs/querying-relations)
+- [Soft Deletes & Auditing](https://uql.app/docs/entities-soft-delete)
+- [Database Migration & Syncing](https://uql.app/docs/migrations)
+
+---
+
+## 🛠 Deep Dive: Tests & Technical Resources
+
+For those who want to see the "engine under the hood," check out these resources in the source code:
+
+- **Entity Mocks**: See how complex entities and virtual fields are defined in [entityMock.ts](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/test/entityMock.ts).
+- **Core Dialect Logic**: The foundation of our context-aware SQL generation in [abstractSqlDialect.ts](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/dialect/abstractSqlDialect.ts).
+- **Comprehensive Test Suite**:
+  - [Abstract SQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/dialect/abstractSqlDialect-spec.ts): The base test suite shared by all dialects.
+  - [PostgreSQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/postgres/src/postgresDialect.spec.ts) | [MySQL Spec](https://github.com/rogerpadilla/uql/blob/main/packages/mysql/src/mysqlDialect.spec.ts) | [SQLite Spec](https://github.com/rogerpadilla/uql/blob/main/packages/sqlite/src/sqliteDialect.spec.ts).
+  - [Querier Integration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/core/src/querier/abstractSqlQuerier-spec.ts): Testing the interaction between SQL generation and connection management.
+  - [MongoDB Migration Tests](https://github.com/rogerpadilla/uql/blob/main/packages/uql/src/migrate/migrator-mongo.it.ts): Integration tests ensuring correct collection and index synchronization for MongoDB.

package/dist/browser/http/bus.d.ts

@@ -0,0 +1,3 @@
+import type { RequestCallback, RequestNotification } from '../type/index.js';
+export declare function notify(notification: RequestNotification): void;
+export declare function on(cb: RequestCallback): () => void;

package/dist/browser/http/bus.js

@@ -0,0 +1,14 @@
+const subscriptors = [];
+export function notify(notification) {
+    for (const subscriptor of subscriptors) {
+        subscriptor(notification);
+    }
+}
+export function on(cb) {
+    subscriptors.push(cb);
+    const index = subscriptors.length - 1;
+    return () => {
+        subscriptors.splice(index, 1);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2Jyb3dzZXIvaHR0cC9idXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxZQUFZLEdBQXNCLEVBQUUsQ0FBQztBQUUzQyxNQUFNLFVBQVUsTUFBTSxDQUFDLFlBQWlDO0lBQ3RELEtBQUssTUFBTSxXQUFXLElBQUksWUFBWSxFQUFFLENBQUM7UUFDdkMsV0FBVyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQzVCLENBQUM7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLEVBQUUsQ0FBQyxFQUFtQjtJQUNwQyxZQUFZLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3RCLE1BQU0sS0FBSyxHQUFHLFlBQVksQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBQ3RDLE9BQU8sR0FBUyxFQUFFO1FBQ2hCLFlBQVksQ0FBQyxNQUFNLENBQUMsS0FBSyxFQUFFLENBQUMsQ0FBQyxDQUFDO0lBQ2hDLENBQUMsQ0FBQztBQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgdHlwZSB7IFJlcXVlc3RDYWxsYmFjaywgUmVxdWVzdE5vdGlmaWNhdGlvbiB9IGZyb20gJy4uL3R5cGUvaW5kZXguanMnO1xuXG5jb25zdCBzdWJzY3JpcHRvcnM6IFJlcXVlc3RDYWxsYmFja1tdID0gW107XG5cbmV4cG9ydCBmdW5jdGlvbiBub3RpZnkobm90aWZpY2F0aW9uOiBSZXF1ZXN0Tm90aWZpY2F0aW9uKTogdm9pZCB7XG4gIGZvciAoY29uc3Qgc3Vic2NyaXB0b3Igb2Ygc3Vic2NyaXB0b3JzKSB7XG4gICAgc3Vic2NyaXB0b3Iobm90aWZpY2F0aW9uKTtcbiAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gb24oY2I6IFJlcXVlc3RDYWxsYmFjayk6ICgpID0+IHZvaWQge1xuICBzdWJzY3JpcHRvcnMucHVzaChjYik7XG4gIGNvbnN0IGluZGV4ID0gc3Vic2NyaXB0b3JzLmxlbmd0aCAtIDE7XG4gIHJldHVybiAoKTogdm9pZCA9PiB7XG4gICAgc3Vic2NyaXB0b3JzLnNwbGljZShpbmRleCwgMSk7XG4gIH07XG59XG4iXX0=

package/dist/browser/http/http.d.ts

@@ -0,0 +1,6 @@
+import type { RequestOptions, RequestSuccessResponse } from '../type/index.js';
+export declare function get<T>(url: string, opts?: RequestOptions): Promise<RequestSuccessResponse<T>>;
+export declare function post<T>(url: string, payload: unknown, opts?: RequestOptions): Promise<RequestSuccessResponse<T>>;
+export declare function patch<T>(url: string, payload: unknown, opts?: RequestOptions): Promise<RequestSuccessResponse<T>>;
+export declare function put<T>(url: string, payload: unknown, opts?: RequestOptions): Promise<RequestSuccessResponse<T>>;
+export declare function remove<T>(url: string, opts?: RequestOptions): Promise<RequestSuccessResponse<T>>;

package/dist/browser/http/http.js

@@ -0,0 +1,45 @@
+import { notify } from './bus.js';
+export function get(url, opts) {
+    return request(url, { method: 'get' }, opts);
+}
+export function post(url, payload, opts) {
+    const body = JSON.stringify(payload);
+    return request(url, { method: 'post', body }, opts);
+}
+export function patch(url, payload, opts) {
+    const body = JSON.stringify(payload);
+    return request(url, { method: 'patch', body }, opts);
+}
+export function put(url, payload, opts) {
+    const body = JSON.stringify(payload);
+    return request(url, { method: 'put', body }, opts);
+}
+export function remove(url, opts) {
+    return request(url, { method: 'delete' }, opts);
+}
+function request(url, init, opts) {
+    notify({ phase: 'start', opts });
+    init.headers = {
+        accept: 'application/json',
+        'content-type': 'application/json',
+    };
+    return fetch(url, init)
+        .then((rawResp) => rawResp.json().then((resp) => {
+        const isSuccess = rawResp.status >= 200 && rawResp.status < 300;
+        if (isSuccess) {
+            notify({ phase: 'success', opts });
+            return resp;
+        }
+        const errorResp = resp;
+        notify({
+            phase: 'error',
+            error: errorResp.error,
+            opts,
+        });
+        throw Error(errorResp.error.message);
+    }))
+        .finally(() => {
+        notify({ phase: 'complete', opts });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/browser/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bus.js';
+export * from './http.js';

package/dist/browser/http/index.js

@@ -0,0 +1,3 @@
+export * from './bus.js';
+export * from './http.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYnJvd3Nlci9odHRwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9idXMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9odHRwLmpzJztcbiJdfQ==

package/dist/browser/index.d.ts

@@ -0,0 +1,4 @@
+export * from './http/index.js';
+export * from './options.js';
+export * from './querier/index.js';
+export * from './type/index.js';

package/dist/browser/index.js

@@ -0,0 +1,5 @@
+export * from './http/index.js';
+export * from './options.js';
+export * from './querier/index.js';
+export * from './type/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnJvd3Nlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxpQkFBaUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaHR0cC9pbmRleC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL29wdGlvbnMuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdWVyaWVyL2luZGV4LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZS9pbmRleC5qcyc7XG4iXX0=

package/dist/browser/options.d.ts

@@ -0,0 +1,4 @@
+import type { ClientQuerier, ClientQuerierPool } from './type/index.js';
+export declare function setQuerierPool<T extends ClientQuerierPool>(pool: T): void;
+export declare function getQuerierPool(): ClientQuerierPool;
+export declare function getQuerier(): ClientQuerier;

package/dist/browser/options.js

@@ -0,0 +1,14 @@
+import { HttpQuerier } from './querier/httpQuerier.js';
+let defaultPool = {
+    getQuerier: () => new HttpQuerier('/api'),
+};
+export function setQuerierPool(pool) {
+    defaultPool = pool;
+}
+export function getQuerierPool() {
+    return defaultPool;
+}
+export function getQuerier() {
+    return getQuerierPool().getQuerier();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3B0aW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icm93c2VyL29wdGlvbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBR3ZELElBQUksV0FBVyxHQUFzQjtJQUNuQyxVQUFVLEVBQUUsR0FBRyxFQUFFLENBQUMsSUFBSSxXQUFXLENBQUMsTUFBTSxDQUFDO0NBQzFDLENBQUM7QUFFRixNQUFNLFVBQVUsY0FBYyxDQUE4QixJQUFPO0lBQ2pFLFdBQVcsR0FBRyxJQUFJLENBQUM7QUFDckIsQ0FBQztBQUVELE1BQU0sVUFBVSxjQUFjO0lBQzVCLE9BQU8sV0FBVyxDQUFDO0FBQ3JCLENBQUM7QUFFRCxNQUFNLFVBQVUsVUFBVTtJQUN4QixPQUFPLGNBQWMsRUFBRSxDQUFDLFVBQVUsRUFBRSxDQUFDO0FBQ3ZDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBIdHRwUXVlcmllciB9IGZyb20gJy4vcXVlcmllci9odHRwUXVlcmllci5qcyc7XG5pbXBvcnQgdHlwZSB7IENsaWVudFF1ZXJpZXIsIENsaWVudFF1ZXJpZXJQb29sIH0gZnJvbSAnLi90eXBlL2luZGV4LmpzJztcblxubGV0IGRlZmF1bHRQb29sOiBDbGllbnRRdWVyaWVyUG9vbCA9IHtcbiAgZ2V0UXVlcmllcjogKCkgPT4gbmV3IEh0dHBRdWVyaWVyKCcvYXBpJyksXG59O1xuXG5leHBvcnQgZnVuY3Rpb24gc2V0UXVlcmllclBvb2w8VCBleHRlbmRzIENsaWVudFF1ZXJpZXJQb29sPihwb29sOiBUKSB7XG4gIGRlZmF1bHRQb29sID0gcG9vbDtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGdldFF1ZXJpZXJQb29sKCk6IENsaWVudFF1ZXJpZXJQb29sIHtcbiAgcmV0dXJuIGRlZmF1bHRQb29sO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gZ2V0UXVlcmllcigpOiBDbGllbnRRdWVyaWVyIHtcbiAgcmV0dXJuIGdldFF1ZXJpZXJQb29sKCkuZ2V0UXVlcmllcigpO1xufVxuIl19

package/dist/browser/querier/genericClientRepository.d.ts

@@ -0,0 +1,17 @@
+import type { IdValue, Query, QueryOne, QueryOptions, QuerySearch, Type } from '../../type/index.js';
+import type { ClientQuerier, ClientRepository, RequestOptions } from '../type/index.js';
+export declare class GenericClientRepository<E> implements ClientRepository<E> {
+    readonly entity: Type<E>;
+    readonly querier: ClientQuerier;
+    constructor(entity: Type<E>, querier: ClientQuerier);
+    findOneById(id: IdValue<E>, q?: QueryOne<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<E>>;
+    findOne(q: QueryOne<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<E>>;
+    findMany(q: Query<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<E[]>>;
+    findManyAndCount(q: Query<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<E[]>>;
+    count(qm?: QuerySearch<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<number>>;
+    insertOne(payload: E, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>>>;
+    updateOneById(id: IdValue<E>, payload: E, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>>>;
+    saveOne(payload: E, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>>>;
+    deleteOneById(id: IdValue<E>, opts?: QueryOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>>>;
+    deleteMany(qm: QuerySearch<E>, opts?: QueryOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>[]>>;
+}

package/dist/browser/querier/genericClientRepository.js

@@ -0,0 +1,39 @@
+export class GenericClientRepository {
+    entity;
+    querier;
+    constructor(entity, querier) {
+        this.entity = entity;
+        this.querier = querier;
+    }
+    findOneById(id, q, opts) {
+        return this.querier.findOneById(this.entity, id, q, opts);
+    }
+    findOne(q, opts) {
+        return this.querier.findOne(this.entity, q, opts);
+    }
+    findMany(q, opts) {
+        return this.querier.findMany(this.entity, q, opts);
+    }
+    findManyAndCount(q, opts) {
+        return this.querier.findManyAndCount(this.entity, q, opts);
+    }
+    count(qm, opts) {
+        return this.querier.count(this.entity, qm, opts);
+    }
+    insertOne(payload, opts) {
+        return this.querier.insertOne(this.entity, payload, opts);
+    }
+    updateOneById(id, payload, opts) {
+        return this.querier.updateOneById(this.entity, id, payload, opts);
+    }
+    saveOne(payload, opts) {
+        return this.querier.saveOne(this.entity, payload, opts);
+    }
+    deleteOneById(id, opts) {
+        return this.querier.deleteOneById(this.entity, id, opts);
+    }
+    deleteMany(qm, opts) {
+        return this.querier.deleteMany(this.entity, qm, opts);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/browser/querier/httpQuerier.d.ts

@@ -0,0 +1,20 @@
+import type { IdValue, Query, QueryOne, QueryOptions, QuerySearch, Type } from '../../type/index.js';
+import type { ClientQuerier, ClientRepository, RequestFindOptions, RequestOptions } from '../type/index.js';
+export declare class HttpQuerier implements ClientQuerier {
+    readonly basePath: string;
+    constructor(basePath: string);
+    findOneById<E>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<E>>;
+    findOne<E>(entity: Type<E>, q: QueryOne<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<E>>;
+    findMany<E>(entity: Type<E>, q: Query<E>, opts?: RequestFindOptions): Promise<import("../type/request.js").RequestSuccessResponse<E[]>>;
+    findManyAndCount<E>(entity: Type<E>, q: Query<E>, opts?: RequestFindOptions): Promise<import("../type/request.js").RequestSuccessResponse<E[]>>;
+    count<E>(entity: Type<E>, q: QuerySearch<E>, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<number>>;
+    insertOne<E>(entity: Type<E>, payload: E, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<any>>;
+    updateOneById<E>(entity: Type<E>, id: IdValue<E>, payload: E, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>>>;
+    saveOne<E>(entity: Type<E>, payload: E, opts?: RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<any>> | Promise<{
+        data: E[import("../../type/entity.js").IdKey<E>];
+    }>;
+    deleteOneById<E>(entity: Type<E>, id: IdValue<E>, opts?: QueryOptions & RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>>>;
+    deleteMany<E>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions & RequestOptions): Promise<import("../type/request.js").RequestSuccessResponse<IdValue<E>[]>>;
+    getRepository<E>(entity: Type<E>): ClientRepository<E>;
+    getBasePath<E>(entity: Type<E>): string;
+}