@uql/core 1.0.12 → 3.0.0

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('&') : '';
+}

package/src/browser/type/clientQuerier.ts

@@ -0,0 +1,45 @@
+import type { IdValue, Query, QueryOne, QueryOptions, QuerySearch, Type, UniversalQuerier } from '../../type/index.js';
+import type { ClientRepository } from './clientRepository.js';
+import type { RequestOptions, RequestSuccessResponse } from './request.js';
+
+export interface ClientQuerier extends UniversalQuerier {
+  findOneById<E>(
+    entity: Type<E>,
+    id: IdValue<E>,
+    q?: QueryOne<E>,
+    opts?: RequestOptions,
+  ): Promise<RequestSuccessResponse<E>>;
+
+  findOne<E>(entity: Type<E>, q: QueryOne<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E>>;
+
+  findMany<E>(entity: Type<E>, q: Query<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E[]>>;
+
+  findManyAndCount<E>(entity: Type<E>, q: Query<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E[]>>;
+
+  count<E>(entity: Type<E>, q?: QuerySearch<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<number>>;
+
+  insertOne<E>(entity: Type<E>, payload: E, opts?: RequestOptions): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  updateOneById<E>(
+    entity: Type<E>,
+    id: IdValue<E>,
+    payload: E,
+    opts?: RequestOptions,
+  ): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  saveOne<E>(entity: Type<E>, payload: E, opts?: RequestOptions): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  deleteOneById<E>(
+    entity: Type<E>,
+    id: IdValue<E>,
+    opts?: QueryOptions & RequestOptions,
+  ): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  deleteMany<E>(
+    entity: Type<E>,
+    qm: QuerySearch<E>,
+    opts?: QueryOptions & RequestOptions,
+  ): Promise<RequestSuccessResponse<IdValue<E>[]>>;
+
+  getRepository<E>(entity: Type<E>): ClientRepository<E>;
+}

package/src/browser/type/clientQuerierPool.ts

@@ -0,0 +1,5 @@
+import type { ClientQuerier } from './clientQuerier.js';
+
+export type ClientQuerierPool = {
+  getQuerier(): ClientQuerier;
+};

package/src/browser/type/clientRepository.ts

@@ -0,0 +1,22 @@
+import type { IdValue, Query, QueryOne, QueryOptions, QuerySearch, UniversalRepository } from '../../type/index.js';
+import type { RequestOptions, RequestSuccessResponse } from './request.js';
+
+export interface ClientRepository<E> extends UniversalRepository<E> {
+  findOneById(id: IdValue<E>, q?: QueryOne<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E>>;
+
+  findOne(qm: QueryOne<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E>>;
+
+  findMany(qm: Query<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E[]>>;
+
+  findManyAndCount(qm: Query<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<E[]>>;
+
+  count(qm?: QuerySearch<E>, opts?: RequestOptions): Promise<RequestSuccessResponse<number>>;
+
+  insertOne(payload: E, opts?: RequestOptions): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  saveOne(payload: E, opts?: RequestOptions): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  deleteOneById(id: IdValue<E>, opts?: QueryOptions & RequestOptions): Promise<RequestSuccessResponse<IdValue<E>>>;
+
+  deleteMany(qm: QuerySearch<E>, opts?: QueryOptions & RequestOptions): Promise<RequestSuccessResponse<IdValue<E>[]>>;
+}

package/src/browser/type/index.ts

@@ -0,0 +1,4 @@
+export * from './clientQuerier.js';
+export * from './clientQuerierPool.js';
+export * from './clientRepository.js';
+export * from './request.js';

package/src/browser/type/request.ts

@@ -0,0 +1,25 @@
+export type RequestSuccessResponse<E> = {
+  data: E;
+  count?: number;
+};
+
+export type RequestErrorResponse = {
+  readonly error: {
+    readonly message: string;
+    readonly code: number;
+  };
+};
+
+export type RequestOptions = {
+  silent?: boolean;
+};
+
+export type RequestFindOptions = RequestOptions & {
+  count?: boolean;
+};
+
+type RequestBaseNotification = { readonly opts?: RequestOptions };
+type RequestSuccessNotification = { readonly phase: 'start' | 'success' | 'complete' } & RequestBaseNotification;
+type RequestErrorNotification = { readonly phase: 'error' } & RequestErrorResponse & RequestBaseNotification;
+export type RequestNotification = RequestSuccessNotification | RequestErrorNotification;
+export type RequestCallback = (msg: RequestNotification) => any;

package/src/dialect/abstractDialect.ts

@@ -0,0 +1,28 @@
+import type { EntityMeta, FieldOptions, NamingStrategy, Type } from '../type/index.js';
+
+/**
+ * Base abstract class for all database dialects (SQL and NoSQL).
+ */
+export abstract class AbstractDialect {
+  constructor(readonly namingStrategy?: NamingStrategy) {}
+
+  /**
+   * Resolve the table name for an entity, applying naming strategy if necessary.
+   */
+  resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string {
+    if (meta.name !== entity.name || !this.namingStrategy) {
+      return meta.name;
+    }
+    return this.namingStrategy.tableName(meta.name);
+  }
+
+  /**
+   * Resolve the column/field name for a property, applying naming strategy if necessary.
+   */
+  resolveColumnName(key: string, field: FieldOptions): string {
+    if (!field || field.name !== key || !this.namingStrategy) {
+      return field?.name ?? key;
+    }
+    return this.namingStrategy.columnName(field.name);
+  }
+}