@uql/core 3.1.0 → 3.1.2

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

@@ -1,70 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

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

package/src/browser/index.ts

@@ -1,4 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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

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

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

@@ -1,35 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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

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

package/src/browser/type/clientRepository.ts

@@ -1,22 +0,0 @@
-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

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

package/src/browser/type/request.ts

@@ -1,25 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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);
-  }
-}