@uql/core 1.0.12 → 3.1.0

package/dist/util/sql.util.js

@@ -0,0 +1,78 @@
+import { getKeys, hasKeys } from './object.util.js';
+export function flatObject(obj, pre) {
+    return getKeys(obj).reduce((acc, key) => flatObjectEntry(acc, key, obj[key], typeof obj[key] === 'object' ? '' : pre), {});
+}
+function flatObjectEntry(map, key, val, pre) {
+    const prefix = pre ? `${pre}.${key}` : key;
+    return typeof val === 'object'
+        ? getKeys(val).reduce((acc, prop) => flatObjectEntry(acc, prop, val[prop], prefix), map)
+        : { ...map, [prefix]: val };
+}
+export function unflatObjects(objects) {
+    if (!Array.isArray(objects) || !objects.length) {
+        return objects;
+    }
+    const attrsPaths = obtainAttrsPaths(objects[0]);
+    if (!hasKeys(attrsPaths)) {
+        return objects;
+    }
+    return objects.map((row) => {
+        const dto = {};
+        for (const col in row) {
+            if (row[col] === null) {
+                continue;
+            }
+            const attrPath = attrsPaths[col];
+            if (attrPath) {
+                const target = attrPath.slice(0, -1).reduce((acc, key) => {
+                    if (typeof acc[key] !== 'object') {
+                        acc[key] = {};
+                    }
+                    return acc[key];
+                }, dto);
+                target[attrPath[attrPath.length - 1]] = row[col];
+            }
+            else {
+                dto[col] = row[col];
+            }
+        }
+        return dto;
+    });
+}
+export function obtainAttrsPaths(row) {
+    return getKeys(row).reduce((acc, col) => {
+        // Support both dot notation (legacy) and underscore notation (new)
+        if (col.includes('.')) {
+            acc[col] = col.split('.');
+        }
+        else if (col.includes('_') && col !== col.toUpperCase()) {
+            // Convert underscore to dot notation for nested paths
+            // Skip all-uppercase (like UPPER_CASE constants)
+            acc[col] = col.split('_');
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Escape a SQL identifier (table name, column name, etc.)
+ * @param val the identifier to escape
+ * @param escapeIdChar the escape character to use (e.g. ` or ")
+ * @param forbidQualified whether to forbid qualified identifiers (containing dots)
+ * @param addDot whether to add a dot suffix
+ */
+export function escapeSqlId(val, escapeIdChar = '`', forbidQualified, addDot) {
+    if (!val) {
+        return '';
+    }
+    if (!forbidQualified && val.includes('.')) {
+        const result = val
+            .split('.')
+            .map((it) => escapeSqlId(it, escapeIdChar, true))
+            .join('.');
+        return addDot ? result + '.' : result;
+    }
+    const escaped = escapeIdChar + val.replace(new RegExp(escapeIdChar, 'g'), escapeIdChar + escapeIdChar) + escapeIdChar;
+    const suffix = addDot ? '.' : '';
+    return escaped + suffix;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sql.util.js","sourceRoot":"","sources":["../../src/util/sql.util.ts"],"names":[],"mappings":"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","sourcesContent":["import type { FieldValue, Key } from '../type/index.js';\nimport { getKeys, hasKeys } from './object.util.js';\n\nexport function flatObject<E>(obj: E, pre?: string): E {\n  return getKeys(obj).reduce(\n    (acc, key) => flatObjectEntry(acc, key, obj[key as Key<E>], typeof obj[key as Key<E>] === 'object' ? '' : pre),\n    {} as E,\n  );\n}\n\nfunction flatObjectEntry<E>(map: E, key: string, val: any, pre?: string): E {\n  const prefix = pre ? `${pre}.${key}` : key;\n  return typeof val === 'object'\n    ? getKeys(val).reduce((acc, prop) => flatObjectEntry(acc, prop, val[prop], prefix), map)\n    : { ...map, [prefix]: val };\n}\n\nexport function unflatObjects<T>(objects: T[]): T[] {\n  if (!Array.isArray(objects) || !objects.length) {\n    return objects;\n  }\n\n  const attrsPaths = obtainAttrsPaths(objects[0]);\n\n  if (!hasKeys(attrsPaths)) {\n    return objects;\n  }\n\n  return objects.map((row) => {\n    const dto = {} as T;\n\n    for (const col in row) {\n      if (row[col] === null) {\n        continue;\n      }\n      const attrPath = attrsPaths[col];\n      if (attrPath) {\n        const target = attrPath.slice(0, -1).reduce(\n          (acc, key) => {\n            if (typeof acc[key as Key<T>] !== 'object') {\n              acc[key as Key<T>] = {} as FieldValue<T>;\n            }\n            return acc[key as Key<T>];\n          },\n          dto as Record<string, any>,\n        );\n        target[attrPath[attrPath.length - 1]] = row[col];\n      } else {\n        dto[col] = row[col];\n      }\n    }\n\n    return dto;\n  });\n}\n\nexport function obtainAttrsPaths<T>(row: T) {\n  return getKeys(row).reduce(\n    (acc, col) => {\n      // Support both dot notation (legacy) and underscore notation (new)\n      if (col.includes('.')) {\n        acc[col] = col.split('.');\n      } else if (col.includes('_') && col !== col.toUpperCase()) {\n        // Convert underscore to dot notation for nested paths\n        // Skip all-uppercase (like UPPER_CASE constants)\n        acc[col] = col.split('_');\n      }\n      return acc;\n    },\n    {} as { [k: string]: string[] },\n  );\n}\n\n/**\n * Escape a SQL identifier (table name, column name, etc.)\n * @param val the identifier to escape\n * @param escapeIdChar the escape character to use (e.g. ` or \")\n * @param forbidQualified whether to forbid qualified identifiers (containing dots)\n * @param addDot whether to add a dot suffix\n */\nexport function escapeSqlId(\n  val: string,\n  escapeIdChar: '`' | '\"' = '`',\n  forbidQualified?: boolean,\n  addDot?: boolean,\n): string {\n  if (!val) {\n    return '';\n  }\n\n  if (!forbidQualified && val.includes('.')) {\n    const result = val\n      .split('.')\n      .map((it) => escapeSqlId(it, escapeIdChar, true))\n      .join('.');\n    return addDot ? result + '.' : result;\n  }\n\n  const escaped = escapeIdChar + val.replace(new RegExp(escapeIdChar, 'g'), escapeIdChar + escapeIdChar) + escapeIdChar;\n\n  const suffix = addDot ? '.' : '';\n\n  return escaped + suffix;\n}\n"]}

package/{util → dist/util}/string.util.d.ts

@@ -1,3 +1,4 @@
 export declare function kebabCase(val: string): string;
 export declare function upperFirst(text: string): string;
 export declare function lowerFirst(text: string): string;
+export declare function snakeCase(val: string): string;

package/dist/util/string.util.js

@@ -0,0 +1,34 @@
+export function kebabCase(val) {
+    let resp = val.charAt(0).toLowerCase();
+    for (let i = 1; i < val.length; ++i) {
+        resp += val[i] === val[i].toUpperCase() ? '-' + val[i].toLowerCase() : val[i];
+    }
+    return resp;
+}
+export function upperFirst(text) {
+    return text[0].toUpperCase() + text.slice(1);
+}
+export function lowerFirst(text) {
+    return text[0].toLowerCase() + text.slice(1);
+}
+export function snakeCase(val) {
+    if (val === undefined || val === null) {
+        return val;
+    }
+    if (!val) {
+        return '';
+    }
+    let resp = val.charAt(0).toLowerCase();
+    for (let i = 1; i < val.length; ++i) {
+        const char = val[i];
+        const charLower = char.toLowerCase();
+        if (char !== charLower && char === char.toUpperCase()) {
+            resp += '_' + charLower;
+        }
+        else {
+            resp += char;
+        }
+    }
+    return resp;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,30 +1,97 @@
 {
   "name": "@uql/core",
-  "homepage": "https://nukak.org",
-  "description": "flexible and efficient ORM, with declarative JSON syntax and smart type-safety",
+  "homepage": "https://uql.app",
+  "description": "One Language. Frontend to Backend.",
   "license": "MIT",
-  "version": "1.0.12",
-  "main": "index.js",
+  "version": "3.1.0",
+  "type": "module",
+  "main": "./index.js",
   "types": "./index.d.ts",
+  "bin": {
+    "uql-migrate": "./migrate/cli.js"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./dialect": "./dialect/index.js",
+    "./entity": "./entity/index.js",
+    "./querier": "./querier/index.js",
+    "./repository": "./repository/index.js",
+    "./type": "./type/index.js",
+    "./util": "./util/index.js",
+    "./namingStrategy": "./namingStrategy/index.js",
+    "./migrate": "./migrate/index.js",
+    "./options": "./options.js",
+    "./test": "./test/index.js",
+    "./mysql": "./mysql/index.js",
+    "./postgres": "./postgres/index.js",
+    "./maria": "./maria/index.js",
+    "./sqlite": "./sqlite/index.js",
+    "./mongo": "./mongo/index.js",
+    "./express": "./express/index.js",
+    "./browser": {
+      "types": "./browser/index.d.ts",
+      "import": "./browser/index.js",
+      "default": "./browser/uql-browser.min.js"
+    }
+  },
+  "sideEffects": false,
   "scripts": {
-    "copyfiles": "copyfiles -f package.json ../../README.md ../../CHANGELOG.md dist",
-    "build": "yarn clean && tsc -b tsconfig.build.json && yarn copyfiles",
+    "copyfiles": "copyfiles -f package.json ../README.md ../CHANGELOG.md dist",
+    "compile.browser": "bunchee --clean false --no-dts ./src/browser/index.ts --sourcemap -o ./dist/browser/uql-browser.min.js",
+    "build": "bun run clean && tsc -b tsconfig.build.json && bun run compile.browser && bun run copyfiles",
     "start": "tsc --watch",
     "clean": "rimraf dist *.tsbuildinfo"
   },
   "dependencies": {
-    "reflect-metadata": "^0.1.13",
+    "reflect-metadata": "^0.2.2",
     "sqlstring": "^2.3.3",
-    "tslib": "^2.4.0"
+    "sqlstring-sqlite": "^0.1.1",
+    "tslib": "^2.8.1"
+  },
+  "peerDependencies": {
+    "better-sqlite3": ">=9.0.0",
+    "express": ">=5.0.0",
+    "mariadb": ">=3.0.0",
+    "mongodb": ">=6.0.0",
+    "mysql2": ">=3.0.0",
+    "pg": ">=8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "mariadb": {
+      "optional": true
+    },
+    "mongodb": {
+      "optional": true
+    },
+    "mysql2": {
+      "optional": true
+    },
+    "pg": {
+      "optional": true
+    },
+    "better-sqlite3": {
+      "optional": true
+    }
   },
   "devDependencies": {
-    "@types/node": "^18.0.6",
-    "@types/sqlstring": "^2.3.0",
-    "@types/uuid": "^8.3.4",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.0.3",
+    "@types/pg": "^8.16.0",
+    "@types/sqlstring": "^2.3.2",
+    "better-sqlite3": "^12.5.0",
+    "bunchee": "^6.9.1",
     "copyfiles": "^2.4.1",
-    "rimraf": "^3.0.2",
-    "typescript": "^4.7.4",
-    "uuid": "^8.3.2"
+    "express": "^5.2.1",
+    "mariadb": "^3.4.5",
+    "mongodb": "^7.0.0",
+    "mysql2": "^3.16.0",
+    "pg": "^8.16.3",
+    "rimraf": "^6.1.2",
+    "typescript": "~5.4.5"
   },
   "author": "Roger Padilla",
   "repository": {
@@ -54,10 +121,11 @@
     "dao",
     "transaction",
     "repository",
-    "service"
+    "service",
+    "migrations"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3ced0c218364ddcd9e234096155ff205a7583b13"
-}
+  "gitHead": "47f2055cf30ab5655ac57ba4278e8c7b4541db0b"
+}

package/src/@types/index.d.ts

@@ -0,0 +1 @@
+import './jest';

package/src/@types/jest.d.ts

@@ -0,0 +1,6 @@
+/** biome-ignore-all lint/style/noNamespace: compat */
+declare namespace jest {
+  export interface Expect {
+    toMatch: (received: RegExp) => any;
+  }
+}

package/src/browser/http/bus.spec.ts

@@ -0,0 +1,22 @@
+import { expect, it } from 'bun:test';
+import type { RequestNotification } from '../type/index.js';
+import { notify, on } from './bus.js';
+
+it('bus', () => {
+  const off = on((msg) => {
+    const expected: RequestNotification = {
+      phase: 'start',
+      opts: {
+        silent: true,
+      },
+    };
+    expect(msg).toEqual(expected);
+    off();
+  });
+  notify({
+    phase: 'start',
+    opts: {
+      silent: true,
+    },
+  });
+});

package/src/browser/http/bus.ts

@@ -0,0 +1,17 @@
+import type { RequestCallback, RequestNotification } from '../type/index.js';
+
+const subscriptors: RequestCallback[] = [];
+
+export function notify(notification: RequestNotification): void {
+  for (const subscriptor of subscriptors) {
+    subscriptor(notification);
+  }
+}
+
+export function on(cb: RequestCallback): () => void {
+  subscriptors.push(cb);
+  const index = subscriptors.length - 1;
+  return (): void => {
+    subscriptors.splice(index, 1);
+  };
+}

package/src/browser/http/http.spec.ts

@@ -0,0 +1,70 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test';
+import { get, patch, post, put, remove } from './http.js';
+
+describe('http', () => {
+  beforeEach(() => {
+    globalThis.fetch = jest.fn() as any;
+    (globalThis.fetch as unknown as jest.Mock).mockImplementation(setupFetchStub({}));
+  });
+
+  afterEach(() => {
+    delete globalThis.fetch;
+  });
+
+  it('post', async () => {
+    const body = {};
+    await post('/', body);
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      '/',
+      expect.objectContaining({ body: JSON.stringify(body), method: 'post' }),
+    );
+  });
+
+  it('patch', async () => {
+    const body = {};
+    await patch('/', body);
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      '/',
+      expect.objectContaining({ body: JSON.stringify(body), method: 'patch' }),
+    );
+  });
+
+  it('put', async () => {
+    const body = {};
+    await put('/', body);
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      '/',
+      expect.objectContaining({ body: JSON.stringify(body), method: 'put' }),
+    );
+  });
+
+  it('get', async () => {
+    await get('/?a=1');
+    expect(globalThis.fetch).toHaveBeenCalledWith('/?a=1', expect.objectContaining({ method: 'get' }));
+  });
+
+  it('remove', async () => {
+    await remove('/?a=1');
+    expect(globalThis.fetch).toHaveBeenCalledWith('/?a=1', expect.objectContaining({ method: 'delete' }));
+  });
+
+  it('error', async () => {
+    globalThis.fetch = jest.fn() as any;
+    (globalThis.fetch as unknown as jest.Mock).mockImplementation(setupFetchStubError(new Error('some error')));
+    await expect(remove('/?a=1')).rejects.toThrow('some error');
+  });
+});
+
+function setupFetchStub(data: object) {
+  return async (_url: any) => ({
+    status: 200,
+    json: async () => ({ data }),
+  });
+}
+
+function setupFetchStubError(error: Error) {
+  return async (_url: any) => ({
+    status: 500,
+    json: async () => ({ error }),
+  });
+}

package/src/browser/http/http.ts

@@ -0,0 +1,55 @@
+import type { RequestErrorResponse, RequestOptions, RequestSuccessResponse } from '../type/index.js';
+import { notify } from './bus.js';
+
+export function get<T>(url: string, opts?: RequestOptions) {
+  return request<T>(url, { method: 'get' }, opts);
+}
+
+export function post<T>(url: string, payload: unknown, opts?: RequestOptions) {
+  const body = JSON.stringify(payload);
+  return request<T>(url, { method: 'post', body }, opts);
+}
+
+export function patch<T>(url: string, payload: unknown, opts?: RequestOptions) {
+  const body = JSON.stringify(payload);
+  return request<T>(url, { method: 'patch', body }, opts);
+}
+
+export function put<T>(url: string, payload: unknown, opts?: RequestOptions) {
+  const body = JSON.stringify(payload);
+  return request<T>(url, { method: 'put', body }, opts);
+}
+
+export function remove<T>(url: string, opts?: RequestOptions) {
+  return request<T>(url, { method: 'delete' }, opts);
+}
+
+function request<T>(url: string, init: RequestInit, opts?: RequestOptions) {
+  notify({ phase: 'start', opts });
+
+  init.headers = {
+    accept: 'application/json',
+    'content-type': 'application/json',
+  };
+
+  return fetch(url, init)
+    .then((rawResp) =>
+      rawResp.json().then((resp: unknown) => {
+        const isSuccess = rawResp.status >= 200 && rawResp.status < 300;
+        if (isSuccess) {
+          notify({ phase: 'success', opts });
+          return resp as RequestSuccessResponse<T>;
+        }
+        const errorResp = resp as RequestErrorResponse;
+        notify({
+          phase: 'error',
+          error: errorResp.error,
+          opts,
+        });
+        throw Error(errorResp.error.message);
+      }),
+    )
+    .finally(() => {
+      notify({ phase: 'complete', opts });
+    });
+}

package/src/browser/http/index.ts

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

package/src/browser/index.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/src/browser/options.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'bun:test';
+import { User } from '../test/index.js';
+import { getQuerier, getQuerierPool, setQuerierPool } from './options.js';
+import { GenericClientRepository, HttpQuerier } from './querier/index.js';
+import type { ClientQuerierPool } from './type/clientQuerierPool.js';
+
+describe('options', () => {
+  it('default getQuerier', () => {
+    const querier = getQuerier();
+    expect(querier).toBeInstanceOf(HttpQuerier);
+  });
+
+  it('default querierPool', () => {
+    expect(getQuerierPool()).toBeDefined();
+  });
+
+  it('custom querierPool', () => {
+    const querierMock = new HttpQuerier('/');
+
+    const querierPool: ClientQuerierPool = {
+      getQuerier: () => querierMock,
+    };
+
+    setQuerierPool(querierPool);
+
+    const querier1 = getQuerierPool().getQuerier();
+    expect(querier1).toBe(querierMock);
+
+    const querier2 = getQuerier();
+    expect(querier2).toBe(querierMock);
+
+    const repository1 = querier2.getRepository(User);
+    expect(repository1).toBeInstanceOf(GenericClientRepository);
+
+    expect(getQuerierPool()).toBe(getQuerierPool());
+  });
+});

package/src/browser/options.ts

@@ -0,0 +1,18 @@
+import { HttpQuerier } from './querier/httpQuerier.js';
+import type { ClientQuerier, ClientQuerierPool } from './type/index.js';
+
+let defaultPool: ClientQuerierPool = {
+  getQuerier: () => new HttpQuerier('/api'),
+};
+
+export function setQuerierPool<T extends ClientQuerierPool>(pool: T) {
+  defaultPool = pool;
+}
+
+export function getQuerierPool(): ClientQuerierPool {
+  return defaultPool;
+}
+
+export function getQuerier(): ClientQuerier {
+  return getQuerierPool().getQuerier();
+}

package/src/browser/querier/genericClientRepository.spec.ts

@@ -0,0 +1,105 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from 'bun:test';
+import { User } from '../../test/index.js';
+import { GenericClientRepository } from './genericClientRepository.js';
+import { HttpQuerier } from './httpQuerier.js';
+
+describe('repository', () => {
+  let repository: GenericClientRepository<User>;
+  const querier = new HttpQuerier('');
+
+  beforeEach(() => {
+    globalThis.fetch = jest.fn() as any;
+    (globalThis.fetch as unknown as jest.Mock).mockImplementation(setupFetchStub({}));
+    repository = new GenericClientRepository(User, querier);
+  });
+
+  afterEach(() => {
+    delete globalThis.fetch;
+  });
+
+  it('count', async () => {
+    await repository.count({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user/count', expect.objectContaining({ method: 'get' }));
+  });
+
+  it('findOneById', async () => {
+    await repository.findOneById(1);
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user/1', expect.objectContaining({ method: 'get' }));
+  });
+
+  it('findOne', async () => {
+    await repository.findOne({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user/one', expect.objectContaining({ method: 'get' }));
+  });
+
+  it('findMany', async () => {
+    await repository.findMany({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user', expect.objectContaining({ method: 'get' }));
+  });
+
+  it('findManyAndCount', async () => {
+    await repository.findManyAndCount({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user?count=true', expect.objectContaining({ method: 'get' }));
+  });
+
+  it('insertOne', async () => {
+    await repository.insertOne({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user', expect.objectContaining({ method: 'post' }));
+  });
+
+  it('updateOneById', async () => {
+    await repository.updateOneById(1, {});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user/1', expect.objectContaining({ method: 'patch' }));
+  });
+
+  it('saveOne', async () => {
+    await repository.saveOne({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user', expect.objectContaining({ method: 'post' }));
+  });
+
+  it('saveOne id', async () => {
+    await repository.saveOne({ id: 2 });
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user/2', expect.objectContaining({ method: 'patch' }));
+  });
+
+  it('deleteOneById', async () => {
+    await repository.deleteOneById(1);
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user/1', expect.objectContaining({ method: 'delete' }));
+  });
+
+  it('deleteOneById soft', async () => {
+    await repository.deleteOneById(1, { softDelete: true });
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      '/user/1?softDelete=true',
+      expect.objectContaining({ method: 'delete' }),
+    );
+  });
+
+  it('deleteMany', async () => {
+    await repository.deleteMany({});
+    expect(globalThis.fetch).toHaveBeenCalledWith('/user', expect.objectContaining({ method: 'delete' }));
+  });
+
+  it('deleteMany soft', async () => {
+    await repository.deleteMany({}, { softDelete: true });
+    expect(globalThis.fetch).toHaveBeenCalledWith(
+      '/user?softDelete=true',
+      expect.objectContaining({ method: 'delete' }),
+    );
+  });
+
+  it('entity property', () => {
+    expect(repository.entity).toBe(User);
+  });
+
+  it('repository property', () => {
+    expect(repository.querier).toBe(querier);
+  });
+});
+
+function setupFetchStub(data: object) {
+  return async (_url: any) => ({
+    status: 200,
+    json: async () => ({ data }),
+  });
+}

package/src/browser/querier/genericClientRepository.ts

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