@uql/core 1.0.11 → 3.0.0

package/package.json

@@ -1,30 +1,97 @@
 {
   "name": "@uql/core",
-  "homepage": "https://uql.io",
-  "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.11",
-  "main": "index.js",
+  "version": "3.0.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",
+    "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": "7a8bbcc2c09c1c4565748013f846f823d38d4dd5"
 }

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);
+  }
+}

package/src/browser/querier/httpQuerier.ts

@@ -0,0 +1,82 @@
+import { getMeta } from '../../entity/index.js';
+import type { IdValue, Query, QueryOne, QueryOptions, QuerySearch, Type } from '../../type/index.js';
+import { kebabCase } from '../../util/index.js';
+import { get, patch, post, remove } from '../http/index.js';
+import type { ClientQuerier, ClientRepository, RequestFindOptions, RequestOptions } from '../type/index.js';
+import { GenericClientRepository } from './genericClientRepository.js';
+import { stringifyQuery } from './querier.util.js';
+
+export class HttpQuerier implements ClientQuerier {
+  constructor(readonly basePath: string) {}
+
+  findOneById<E>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>, opts?: RequestOptions) {
+    const basePath = this.getBasePath(entity);
+    const qs = stringifyQuery(q);
+    return get<E>(`${basePath}/${id}${qs}`, opts);
+  }
+
+  findOne<E>(entity: Type<E>, q: QueryOne<E>, opts?: RequestOptions) {
+    const basePath = this.getBasePath(entity);
+    const qs = stringifyQuery(q);
+    return get<E>(`${basePath}/one${qs}`, opts);
+  }
+
+  findMany<E>(entity: Type<E>, q: Query<E>, opts?: RequestFindOptions) {
+    const data: Query<E> & Pick<typeof opts, 'count'> = { ...q };
+    if (opts?.count) {
+      data.count = true;
+    }
+    const basePath = this.getBasePath(entity);
+    const qs = stringifyQuery(data);
+    return get<E[]>(`${basePath}${qs}`, opts);
+  }
+
+  findManyAndCount<E>(entity: Type<E>, q: Query<E>, opts?: RequestFindOptions) {
+    return this.findMany(entity, q, { ...opts, count: true });
+  }
+
+  count<E>(entity: Type<E>, q: QuerySearch<E>, opts?: RequestOptions) {
+    const basePath = this.getBasePath(entity);
+    const qs = stringifyQuery(q);
+    return get<number>(`${basePath}/count${qs}`, opts);
+  }
+
+  insertOne<E>(entity: Type<E>, payload: E, opts?: RequestOptions) {
+    const basePath = this.getBasePath(entity);
+    return post<any>(basePath, payload, opts);
+  }
+
+  updateOneById<E>(entity: Type<E>, id: IdValue<E>, payload: E, opts?: RequestOptions) {
+    const basePath = this.getBasePath(entity);
+    return patch<typeof id>(`${basePath}/${id}`, payload, opts);
+  }
+
+  saveOne<E>(entity: Type<E>, payload: E, opts?: RequestOptions) {
+    const meta = getMeta(entity);
+    const id = payload[meta.id];
+    if (id) {
+      return this.updateOneById(entity, id, payload, opts).then(() => ({ data: id }));
+    }
+    return this.insertOne(entity, payload, opts);
+  }
+
+  deleteOneById<E>(entity: Type<E>, id: IdValue<E>, opts: QueryOptions & RequestOptions = {}) {
+    const basePath = this.getBasePath(entity);
+    const qs = opts.softDelete ? stringifyQuery({ softDelete: opts.softDelete }) : '';
+    return remove<typeof id>(`${basePath}/${id}${qs}`, opts);
+  }
+
+  deleteMany<E>(entity: Type<E>, q: QuerySearch<E>, opts: QueryOptions & RequestOptions = {}) {
+    const basePath = this.getBasePath(entity);
+    const qs = stringifyQuery(opts.softDelete ? { ...q, softDelete: opts.softDelete } : q);
+    return remove<IdValue<E>[]>(`${basePath}${qs}`, opts);
+  }
+
+  getRepository<E>(entity: Type<E>): ClientRepository<E> {
+    return new GenericClientRepository(entity, this);
+  }
+
+  getBasePath<E>(entity: Type<E>) {
+    return this.basePath + '/' + kebabCase(entity.name);
+  }
+}

package/src/browser/querier/index.ts

@@ -0,0 +1,3 @@
+export * from './genericClientRepository.js';
+export * from './httpQuerier.js';
+export * from './querier.util.js';

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

@@ -0,0 +1,35 @@
+import { expect, it } from 'bun:test';
+import type { Item, User } from '../../test/index.js';
+import type { Query } from '../../type/index.js';
+import { stringifyQuery, stringifyQueryParameter } from './querier.util.js';
+
+it('stringifyQuery -- empty', () => {
+  const source: Query<User> = {};
+  const result = stringifyQuery(source);
+  const expected = '';
+  expect(result).toBe(expected);
+});
+
+it('stringifyQueryParameter', () => {
+  expect(stringifyQueryParameter('select', undefined)).toBe('select=undefined');
+  expect(stringifyQueryParameter('limit', 10, true)).toBe('?limit=10');
+  expect(stringifyQueryParameter('limit', 10)).toBe('limit=10');
+  expect(stringifyQueryParameter('limit', null, true)).toBe('?limit=null');
+  expect(stringifyQueryParameter('sort', { createdAt: -1 })).toBe('sort={"createdAt":-1}');
+});
+
+it('stringifyQuery', () => {
+  expect(stringifyQuery(undefined)).toBe('');
+  expect(stringifyQuery({})).toBe('');
+  expect(stringifyQuery({ $sort: undefined })).toBe('');
+  const source: Query<Item> = {
+    $select: { id: 1, name: 1, tax: true, measureUnit: { $select: { id: 1, name: 1, categoryId: 1 } } },
+    $where: { name: 'Batman', companyId: 38 },
+    $sort: { companyId: 1, name: -1 },
+    $limit: 5,
+  };
+  const result = stringifyQuery(source);
+  const expected =
+    '?$select={"id":1,"name":1,"tax":true,"measureUnit":{"$select":{"id":1,"name":1,"categoryId":1}}}&$where={"name":"Batman","companyId":38}&$sort={"companyId":1,"name":-1}&$limit=5';
+  expect(result).toBe(expected);
+});

package/src/browser/querier/querier.util.ts

@@ -0,0 +1,18 @@
+import { getKeys } from '../../util/index.js';
+
+export function stringifyQueryParameter(key: string, value?: unknown, useQuestionMark?: boolean): string {
+  const valStr = typeof value === 'object' && value !== null ? JSON.stringify(value) : value;
+  return (useQuestionMark ? '?' : '') + `${key}=${valStr}`;
+}
+
+export function stringifyQuery(query: object): string {
+  if (!query) {
+    return '';
+  }
+  const keys = getKeys(query);
+  if (keys.length === 0) {
+    return '';
+  }
+  const qsArr = keys.filter((key) => query[key] !== undefined).map((key) => stringifyQueryParameter(key, query[key]));
+  return qsArr.length ? '?' + qsArr.join('&') : '';
+}